#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 IT, class RT>
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

		,
		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_);
	}
	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_;
	std::vector<int> *lens_sizes_p_;
	std::vector<std::vector<double>> *lens_ratio_p_;

	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> alpha_ref_;
	std::vector<double> result_;

	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_);
		} 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_);
		}
		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 IT, class RT>
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>(
								  static_cast<double>(height) * (ii + 1) / thread_num + 0.999999) -
							  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_;
	std::vector<int> lens_sizes_;
	std::vector<std::vector<double>> lens_ratio_;

	std::vector<igs::maxmin::thread<IT, RT>> threads_;
	igs::resource::multithread mthread_;
};
}
}

#endif /* !igs_maxmin_multithread_h */