#pragma once

#ifndef igs_maxmin_multithread_h

#define igs_maxmin_multithread_h

#include "igs_ifx_common.h" /* igs::image::rgba */

#include "igs_resource_multithread.h"

#include "igs_maxmin_slrender.h"

namespace igs

{

namespace maxmin

{

template <class class="" it,="" rt=""></class>

class thread : public igs::resource::thread_execute_interface

{ /* thread単位の実行設定 */

public:

	thread() {}

	void setup(

		/* 入出力画像 */

		const IT *inn, IT *out, int height, int width, int channels

		/* Pixel毎に効果の強弱 */

		,

		const RT *ref /* 求める画像(out)と同じ高、幅、チャンネル数 */

		,

		const int ref_mode /* 0=R,1=G,2=B,3=A,4=Luminance,5=Nothing */

		/* Action Geometry */

		,

		int y_begin, int y_end, std::vector<int> *lens_offsets_p, std::vector<int> *lens_sizes_p, std::vector<std::vector<double>> *lens_ratio_p</std::vector<double></int></int>

		,

		double radius, double smooth_outer_range, int polygon_number, double roll_degree

		/* Action Type */

		,

		bool min_sw, bool alpha_rendering_sw, bool add_blend_sw)

	{

		this->inn_ = inn;

		this->out_ = out;

		this->height_ = height;

		this->width_ = width;

		this->channels_ = channels;

		this->ref_ = ref;

		this->ref_mode_ = ref_mode;

		this->y_begin_ = y_begin;

		this->y_end_ = y_end;

		this->lens_offsets_p_ = lens_offsets_p;

		this->lens_sizes_p_ = lens_sizes_p;

		this->lens_ratio_p_ = lens_ratio_p;

		this->radius_ = radius;

		this->smooth_outer_range_ = smooth_outer_range;

		this->polygon_number_ = polygon_number;

		this->roll_degree_ = roll_degree;

		this->min_sw_ = min_sw;

		this->alpha_rendering_sw_ = alpha_rendering_sw;

		this->add_blend_sw_ = add_blend_sw;

		igs::maxmin::slrender::resize(

			static_cast<int>(this->lens_offsets_p_->size()), this->width_, (ref != 0 || 4 <= channels) ? true : false, this->pixe_tracks_, this->alpha_ref_, this->result_);</int>

	}

	void run(void)

	{ /* threadで実行する部分 */

		bool rgb_ren_sw = true;

		bool alp_ren_sw = this->alpha_rendering_sw_;

		bool add_ble_sw = this->add_blend_sw_;

		/* 小さいすぎて処理しない */

		if (this->pixe_tracks_.size() <= 1) {

			rgb_ren_sw = false;

			alp_ren_sw = false;

		} // not render,then copy

		/* first scanline-->next scanlineで処理するので

		かならすchannel毎にまとめてループする */

		if (igs::image::rgba::siz == this->channels_) {

			using namespace igs::image::rgba;

			for (int yy = this->y_begin_; yy <= this->y_end_; ++yy) {

				this->rendering_sl_ch_(yy, alp, alp_ren_sw, false);

			}

			for (int yy = this->y_begin_; yy <= this->y_end_; ++yy) {

				this->rendering_sl_ch_(yy, blu, rgb_ren_sw, add_ble_sw);

			}

			for (int yy = this->y_begin_; yy <= this->y_end_; ++yy) {

				this->rendering_sl_ch_(yy, gre, rgb_ren_sw, add_ble_sw);

			}

			for (int yy = this->y_begin_; yy <= this->y_end_; ++yy) {

				this->rendering_sl_ch_(yy, red, rgb_ren_sw, add_ble_sw);

			}

		} else if (igs::image::rgb::siz == this->channels_) {

			using namespace igs::image::rgb;

			for (int yy = this->y_begin_; yy <= this->y_end_; ++yy) {

				this->rendering_sl_ch_(yy, blu, rgb_ren_sw, add_ble_sw);

			}

			for (int yy = this->y_begin_; yy <= this->y_end_; ++yy) {

				this->rendering_sl_ch_(yy, gre, rgb_ren_sw, add_ble_sw);

			}

			for (int yy = this->y_begin_; yy <= this->y_end_; ++yy) {

				this->rendering_sl_ch_(yy, red, rgb_ren_sw, add_ble_sw);

			}

		} else if (1 == this->channels_) { /* grayscale */

			for (int yy = this->y_begin_; yy <= this->y_end_; ++yy) {

				this->rendering_sl_ch_(yy, 0, rgb_ren_sw, add_ble_sw);

			}

		}

	}

	void clear(void)

	{

		igs::maxmin::slrender::clear(

			this->pixe_tracks_,

			this->alpha_ref_,

			this->result_);

	}

private:

	const IT *inn_;

	IT *out_;

	int height_;

	int width_;

	int channels_;

	const RT *ref_;

	int ref_mode_;

	int y_begin_;

	int y_end_;

	std::vector<int> *lens_offsets_p_;</int>

	std::vector<int> *lens_sizes_p_;</int>

	std::vector<std::vector<double>> *lens_ratio_p_;</std::vector<double>

	double radius_;

	double smooth_outer_range_;

	int polygon_number_;

	double roll_degree_;

	bool min_sw_;

	bool alpha_rendering_sw_;

	bool add_blend_sw_;

	std::vector<std::vector<double>> pixe_tracks_;</std::vector<double>

	std::vector<double> alpha_ref_;</double>

	std::vector<double> result_;</double>

	void rendering_sl_ch_(

		const int yy, const int zz, const bool render_sw, const bool add_blend_sw)

	{

		if (!render_sw) {

			igs::maxmin::getput::copy(

				this->inn_, this->height_, this->width_, this->channels_, yy, zz, this->out_);

			return;

		}

		if (yy == this->y_begin_) {

			igs::maxmin::getput::get_first(

				this->inn_, this->out_, this->height_, this->width_, this->channels_, this->ref_, this->ref_mode_, yy, zz, static_cast<int>(this->pixe_tracks_.size() / 2), add_blend_sw, this->pixe_tracks_, this->alpha_ref_, this->result_);</int>

		} else {

			igs::maxmin::slrender::shift(this->pixe_tracks_);

			igs::maxmin::getput::get_next(

				this->inn_, this->out_, this->height_, this->width_, this->channels_, this->ref_, this->ref_mode_, yy, zz, static_cast<int>(this->pixe_tracks_.size() / 2), add_blend_sw, this->pixe_tracks_, this->alpha_ref_, this->result_);</int>

		}

		igs::maxmin::slrender::render(

			this->radius_, this->smooth_outer_range_, this->polygon_number_, this->roll_degree_, this->min_sw_, *(this->lens_offsets_p_), *(this->lens_sizes_p_), *(this->lens_ratio_p_), this->pixe_tracks_, this->alpha_ref_, this->result_);

		igs::maxmin::getput::put(

			this->result_, this->height_, this->width_, this->channels_, yy, zz, this->out_);

	}

};

}

}

//------------------------------------------------------------

#include "igs_maxmin_lens_matrix.h"

namespace igs

{

namespace maxmin

{

template <class class="" it,="" rt=""></class>

class multithread

{

public:

	multithread(

		/* 入出力画像 */

		const IT *inn, IT *out, const int height, const int width, const int channels

		/* Pixel毎に効果の強弱 */

		,

		const RT *ref /* 求める画像(out)と同じ高、幅、チャンネル数 */

		,

		const int ref_mode /* 0=R,1=G,2=B,3=A,4=Luminance,5=Nothing */

		/* Action Geometry */

		,

		const double radius /* =1.0  0..100...DOUBLE_MAX */

		,

		const double smooth_outer_range /*=1.0  0..100...DOUBLE_MAX */

		,

		const int polygon_number /* =2    2...16...INT_MAX */

		,

		const double roll_degree /* =0.0  0...360...DOUBLE_MAX */

		/* Action Type */

		,

		const bool min_sw /* =false */

		,

		const bool alpha_rendering_sw /* =true */

		,

		const bool add_blend_sw /* =false */

		/* Speed up */

		,

		const int number_of_thread /* =1    1...24...INT_MAX */

		)

	{

		/*--------------メモリ確保--------------------------*/

		igs::maxmin::alloc_and_shape_lens_matrix(

			radius, radius + smooth_outer_range, polygon_number, roll_degree, this->lens_offsets_, this->lens_sizes_, this->lens_ratio_);

		/*-------スレッド毎の処理指定-----------------------*/

		int thread_num = number_of_thread;

		/* ゼロ以下の場合強制変更。そもそもGUIでエラーにすべき */

		if (thread_num < 1) {

			thread_num = 1;

		}

		/* 高さより多い場合強制変更。そもそもGUIでエラーにすべき */

		if (height < thread_num) {

			thread_num = height;

		}

		/* threadメモリ確保 */

		this->threads_.resize(thread_num);

		/* thread set */

		int yy = 0;

		for (int ii = 0; ii < thread_num; ++ii) {

			const int y_end = static_cast<int>(</int>

								  static_cast<double>(height) * (ii + 1) / thread_num + 0.999999) -</double>

							  1;

			this->threads_.at(ii).setup(

				inn, out, height, width, channels, ref, ref_mode, yy, y_end, &(this->lens_offsets_), &(this->lens_sizes_), &(this->lens_ratio_)

																															   ,

				radius, smooth_outer_range, polygon_number, roll_degree

				,

				min_sw, alpha_rendering_sw, add_blend_sw);

			yy = y_end;

		}

		/*------スレッド毎のスレッド指定------*/

		for (int ii = 0; ii < thread_num; ++ii) {

			this->mthread_.add(&(this->threads_.at(ii)));

		}

	}

	void run(void)

	{

		this->mthread_.run();

	}

	void clear()

	{

		this->mthread_.clear();

		this->threads_.clear();

		this->lens_ratio_.clear();

		this->lens_sizes_.clear();

		this->lens_offsets_.clear();

	}

private:

	std::vector<int> lens_offsets_;</int>

	std::vector<int> lens_sizes_;</int>

	std::vector<std::vector<double>> lens_ratio_;</std::vector<double>

	std::vector<igs::maxmin::thread<it, rt="">> threads_;</igs::maxmin::thread<it,>

	igs::resource::multithread mthread_;

};

}

}

#endif /* !igs_maxmin_multithread_h */