#include "plugin_param_interface.h"

#include "plugin_utilities.h"

#include "tparamset.h"

#include "../include/ttonecurveparam.h"

#include "../include/toonzqt/fxsettings.h"

#include "plugin_param_traits.h"

/* 公開インターフェイスからは削除 */

enum toonz_param_value_type_enum {

	/* deprecated */

	TOONZ_PARAM_VALUE_TYPE_CHAR = 1,

	TOONZ_PARAM_VALUE_TYPE_INT = 4,

	TOONZ_PARAM_VALUE_TYPE_DOUBLE = 8,

	TOONZ_PARAM_VALUE_TYPE_NB,

	TOONZ_PARAM_VALUE_TYPE_MAX = 0x7FFFFFFF

};

enum toonz_value_unit_enum {

	TOONZ_PARAM_UNIT_NONE,

	TOONZ_PARAM_UNIT_LENGTH,

	TOONZ_PARAM_UNIT_ANGLE,

	TOONZ_PARAM_UNIT_SCALE,

	TOONZ_PARAM_UNIT_PERCENTAGE,

	TOONZ_PARAM_UNIT_PERCENTAGE2,

	TOONZ_PARAM_UNIT_SHEAR,

	TOONZ_PARAM_UNIT_COLOR_CHANNEL,

	TOONZ_PARAM_UNIT_NB,

	TOONZ_PARAM_UNIT_MAX = 0x7FFFFFFF

};

static int set_value_unit(TDoubleParamP param, toonz_value_unit_enum unit);

int hint_default_value(toonz_param_handle_t param, int size_in_bytes, const void *default_value)

{

	if (Param *_ = reinterpret_cast<param *="">(param)) {

		TParamP param = _->param();

		if (TDoubleParamP p = param) {

			if (size_in_bytes != sizeof(double)) {

				return TOONZ_ERROR_INVALID_SIZE;

			}

			const double *values = reinterpret_cast<const *="" double="">(default_value);</const>

			p->setDefaultValue(values[0]);

		} else if (TRangeParamP p = param) {

			if (size_in_bytes != sizeof(double) * 2) {

				return TOONZ_ERROR_INVALID_SIZE;

			}

			const double *values = reinterpret_cast<const *="" double="">(default_value);</const>

			p->setDefaultValue(std::make_pair(values[0], values[1]));

		} else if (TPixelParamP p = param) {

			if (size_in_bytes != sizeof(double) * 4) {

				return TOONZ_ERROR_INVALID_SIZE;

			}

			const double *values = reinterpret_cast<const *="" double="">(default_value);</const>

			p->setDefaultValue(toPixel32(

				TPixelD(values[0], values[1], values[2], values[3])));

		} else if (TPointParamP p = param) {

			if (size_in_bytes != sizeof(double) * 2) {

				return TOONZ_ERROR_INVALID_SIZE;

			}

			const double *values = reinterpret_cast<const *="" double="">(default_value);</const>

			p->setDefaultValue(TPointD(values[0], values[1]));

		} else if (TIntEnumParamP p = param) {

			if (size_in_bytes != sizeof(int)) {

				return TOONZ_ERROR_INVALID_SIZE;

			}

			const int *values = reinterpret_cast<const *="" int="">(default_value);</const>

			p->setDefaultValue(values[0]);

		} else if (TIntParamP p = param) {

			if (size_in_bytes != sizeof(int)) {

				return TOONZ_ERROR_INVALID_SIZE;

			}

			const int *values = reinterpret_cast<const *="" int="">(default_value);</const>

			p->setDefaultValue(values[0]);

		} else if (TBoolParamP p = param) {

			if (size_in_bytes != sizeof(int)) {

				return TOONZ_ERROR_INVALID_SIZE;

			}

			const int *values = reinterpret_cast<const *="" int="">(default_value);</const>

			p->setDefaultValue(values[0]);

		} else if (TSpectrumParamP p = param) {

			const double *values = reinterpret_cast<const *="" double="">(default_value);</const>

			const int count = size_in_bytes / (sizeof(double) * 5);

			std::vector<tspectrum::colorkey> keys(count);</tspectrum::colorkey>

			for (int i = 0; i < count; i++) {

				keys[i].first = values[5 * i + 0];

				keys[i].second = toPixel32(TPixelD(

					values[5 * i + 1], values[5 * i + 2],

					values[5 * i + 3], values[5 * i + 4]));

			}

			p->setDefaultValue(TSpectrum(count, keys.data()));

		} else if (TStringParamP p = param) {

			if (size_in_bytes < 1) {

				return TOONZ_ERROR_INVALID_SIZE;

			}

			const char *values = reinterpret_cast<const *="" char="">(default_value);</const>

			p->setDefaultValue(QString::fromStdString(values).toStdWString());

		} else if (TToneCurveParamP p = param) {

			const double *values = reinterpret_cast<const *="" double="">(default_value);</const>

			const int count = size_in_bytes / (sizeof(double) * 2);

			QList<tpointd> list;</tpointd>

			for (int i = 0; i < count; ++i) {

				list.push_back(TPointD(values[2 * i + 0], values[2 * i + 1]));

			}

			p->setDefaultValue(list);

		} else {

			return TOONZ_ERROR_NOT_IMPLEMENTED;

		}

	} else {

		return TOONZ_ERROR_INVALID_HANDLE;

	}

	return TOONZ_OK;

}

int hint_value_range(toonz_param_handle_t param, const void *minvalue, const void *maxvalue)

{

	if (Param *_ = reinterpret_cast<param *="">(param)) {

		TParamP param = _->param();

		if (TDoubleParamP p = param) {

			p->setValueRange(

				*reinterpret_cast<const *="" double="">(minvalue),</const>

				*reinterpret_cast<const *="" double="">(maxvalue));</const>

		} else if (TRangeParamP p = param) {

			const double minv = *reinterpret_cast<const *="" double="">(minvalue);</const>

			const double maxv = *reinterpret_cast<const *="" double="">(maxvalue);</const>

			p->getMin()->setValueRange(minv, maxv);

			p->getMax()->setValueRange(minv, maxv);

		} else if (TPointParamP p = param) {

			const double minv = *reinterpret_cast<const *="" double="">(minvalue);</const>

			const double maxv = *reinterpret_cast<const *="" double="">(maxvalue);</const>

			p->getX()->setValueRange(minv, maxv);

			p->getY()->setValueRange(minv, maxv);

		} else if (TIntParamP p = param) {

			p->setValueRange(

				*reinterpret_cast<const *="" int="">(minvalue),</const>

				*reinterpret_cast<const *="" int="">(maxvalue));</const>

		} else {

			return TOONZ_ERROR_NOT_IMPLEMENTED;

		}

	} else {

		return TOONZ_ERROR_INVALID_HANDLE;

	}

	return TOONZ_OK;

}

int hint_unit(toonz_param_handle_t param, int unit)

{

	if (Param *_ = reinterpret_cast<param *="">(param)) {

		TParamP param = _->param();

		if (TDoubleParamP p = param) {

			return set_value_unit(p, toonz_value_unit_enum(unit));

		} else if (TRangeParamP p = param) {

			if (const int retval = set_value_unit(p->getMin(), toonz_value_unit_enum(unit))) {

				return retval;

			}

			return set_value_unit(p->getMax(), toonz_value_unit_enum(unit));

		} else if (TPointParamP p = param) {

			if (const int retval = set_value_unit(p->getX(), toonz_value_unit_enum(unit))) {

				return retval;

			}

			return set_value_unit(p->getY(), toonz_value_unit_enum(unit));

		} else {

			return TOONZ_ERROR_NOT_IMPLEMENTED;

		}

	} else {

		return TOONZ_ERROR_INVALID_HANDLE;

	}

}

int hint_item(toonz_param_handle_t param, int item, const char *caption)

{

	if (Param *_ = reinterpret_cast<param *="">(param)) {

		TParamP param = _->param();

		if (TIntEnumParamP p = param) {

			p->addItem(item, caption);

		} else {

			return TOONZ_ERROR_NOT_IMPLEMENTED;

		}

	} else {

		return TOONZ_ERROR_INVALID_HANDLE;

	}

	return TOONZ_OK;

}

int set_description(toonz_param_handle_t param, const char *description)

{

	if (Param *_ = reinterpret_cast<param *="">(param)) {

		TParamP param = _->param();

		param->setDescription(description);

	} else {

		return TOONZ_ERROR_INVALID_HANDLE;

	}

	return TOONZ_OK;

}

static int set_value_unit(TDoubleParamP param, toonz_value_unit_enum unit)

{

	switch (unit) {

	case TOONZ_PARAM_UNIT_NONE:

		break;

	case TOONZ_PARAM_UNIT_LENGTH:

		param->setMeasureName("fxLength");

		break;

	case TOONZ_PARAM_UNIT_ANGLE:

		param->setMeasureName("angle");

		break;

	case TOONZ_PARAM_UNIT_SCALE:

		param->setMeasureName("scale");

		break;

	case TOONZ_PARAM_UNIT_PERCENTAGE:

		param->setMeasureName("percentage");

		break;

	case TOONZ_PARAM_UNIT_PERCENTAGE2:

		param->setMeasureName("percentage2");

		break;

	case TOONZ_PARAM_UNIT_SHEAR:

		param->setMeasureName("shear");

		break;

	case TOONZ_PARAM_UNIT_COLOR_CHANNEL:

		param->setMeasureName("colorChannel");

		break;

	default:

		printf("invalid param unit");

		return TOONZ_ERROR_INVALID_VALUE;

	}

	return TOONZ_OK;

}

int get_value_type(toonz_param_handle_t param, int *pvalue_type)

{

	if (!pvalue_type) {

		return TOONZ_ERROR_NULL;

	}

	if (Param *_ = reinterpret_cast<param *="">(param)) {

		TParamP param = _->param();

		if (TDoubleParamP p = param) {

			*pvalue_type = TOONZ_PARAM_VALUE_TYPE_DOUBLE;

		} else if (TRangeParamP p = param) {

			*pvalue_type = TOONZ_PARAM_VALUE_TYPE_DOUBLE;

		} else if (TPixelParamP p = param) {

			*pvalue_type = TOONZ_PARAM_VALUE_TYPE_DOUBLE;

		} else if (TPointParamP p = param) {

			*pvalue_type = TOONZ_PARAM_VALUE_TYPE_DOUBLE;

		} else if (TIntEnumParamP p = param) {

			*pvalue_type = TOONZ_PARAM_VALUE_TYPE_INT;

		} else if (TIntParamP p = param) {

			*pvalue_type = TOONZ_PARAM_VALUE_TYPE_INT;

		} else if (TBoolParamP p = param) {

			*pvalue_type = TOONZ_PARAM_VALUE_TYPE_INT;

		} else if (TSpectrumParamP p = param) {

			*pvalue_type = TOONZ_PARAM_VALUE_TYPE_DOUBLE;

		} else if (TStringParamP p = param) {

			*pvalue_type = TOONZ_PARAM_VALUE_TYPE_CHAR;

		} else if (TToneCurveParamP p = param) {

			*pvalue_type = TOONZ_PARAM_VALUE_TYPE_DOUBLE;

		} else {

			return TOONZ_ERROR_NOT_IMPLEMENTED;

		}

	} else {

		return TOONZ_ERROR_INVALID_HANDLE;

	}

	return TOONZ_OK;

}

int get_type(toonz_param_handle_t param, double frame, int *ptype, int *pcount)

{

	/* size はほとんどの型で自明なので返さなくてもいいよね? */

	if (!ptype || !pcount)

		return TOONZ_ERROR_NULL;

	if (Param *p = reinterpret_cast<param *="">(param)) {

		toonz_param_type_enum e = toonz_param_type_enum(p->desc()->traits_tag);

		if (e >= TOONZ_PARAM_TYPE_NB)

			return TOONZ_ERROR_NOT_IMPLEMENTED;

		size_t v;

		if (parameter_type_check(p->param().getPointer(), p->desc(), v)) {

			*ptype = p->desc()->traits_tag;

			if (e == TOONZ_PARAM_TYPE_STRING) {

				TStringParam *r = reinterpret_cast<tstringparam *="">(p->param().getPointer());</tstringparam>

				const std::string str = QString::fromStdWString(r->getValue()).toStdString();

				*pcount = str.length() + 1;

			} else if (e == TOONZ_PARAM_TYPE_TONECURVE) {

				TToneCurveParam *r = reinterpret_cast<ttonecurveparam *="">(p->param().getPointer());</ttonecurveparam>

				auto lst = r->getValue(frame);

				*pcount = lst.size();

			} else {

				*pcount = 1; //static_cast< int >(v);

			}

			return TOONZ_OK;

		} else

			return TOONZ_ERROR_NOT_IMPLEMENTED;

	}

	return TOONZ_ERROR_INVALID_HANDLE;

}

int get_value(toonz_param_handle_t param, double frame, int *psize_in_bytes, void *pvalue)

{

	if (!psize_in_bytes) {

		return TOONZ_ERROR_NULL;

	}

	if (!pvalue) {

		int type = 0;

		return get_type(param, frame, &type, psize_in_bytes);

	}

	if (Param *p = reinterpret_cast<param *="">(param)) {

		toonz_param_type_enum e = toonz_param_type_enum(p->desc()->traits_tag);

		if (e >= TOONZ_PARAM_TYPE_NB)

			return TOONZ_ERROR_NOT_IMPLEMENTED;

		size_t v;

		int icounts = *psize_in_bytes;

		if (parameter_read_value(p->param().getPointer(), p->desc(), pvalue, frame, icounts, v)) {

			*psize_in_bytes = v;

			return TOONZ_OK;

		} else

			return TOONZ_ERROR_NOT_IMPLEMENTED;

	}

	return TOONZ_ERROR_INVALID_HANDLE;

}

int get_string_value(toonz_param_handle_t param, int *wholesize, int rcvbufsize, char *pvalue)

{

	if (!pvalue)

		return TOONZ_ERROR_NULL;

	if (Param *p = reinterpret_cast<param *="">(param)) {

		const toonz_param_desc_t *desc = p->desc();

		toonz_param_type_enum e = toonz_param_type_enum(desc->traits_tag);

		size_t vsz;

		TParam *pp = p->param().getPointer();

		if (param_type_check_<tpbind_str_t>(pp, desc, vsz)) {</tpbind_str_t>

			size_t isize = rcvbufsize;

			size_t osize = 0;

			if (param_read_value_<tpbind_str_t>(pp, desc, pvalue, 0, isize, osize)) {</tpbind_str_t>

				if (wholesize)

					*wholesize = static_cast<int>(osize);</int>

				return TOONZ_OK;

			}

		}

	}

	return TOONZ_ERROR_INVALID_HANDLE;

}

int get_spectrum_value(toonz_param_handle_t param, double frame, double x, toonz_param_spectrum_t *pvalue)

{

	if (!pvalue)

		return TOONZ_ERROR_NULL;

	if (Param *p = reinterpret_cast<param *="">(param)) {

		const toonz_param_desc_t *desc = p->desc();

		toonz_param_type_enum e = toonz_param_type_enum(desc->traits_tag);

		size_t vsz;

		TParam *pp = p->param().getPointer();

		if (param_type_check_<tpbind_spc_t>(pp, desc, vsz)) {</tpbind_spc_t>

			size_t isize = 1;

			size_t osize = 0;

			pvalue->w = x;

			if (param_read_value_<tpbind_spc_t>(pp, desc, pvalue, frame, isize, osize)) {</tpbind_spc_t>

				return TOONZ_OK;

			}

		}

	}

	return TOONZ_ERROR_INVALID_HANDLE;

}

int set_value(toonz_param_handle_t param, double frame, int size_in_bytes, const void *pvalue)

{

	if (Param *_ = reinterpret_cast<param *="">(param)) {

		TParamP param = _->param();

		if (TDoubleParamP p = param) {

			if (size_in_bytes != sizeof(double)) {

				return TOONZ_ERROR_INVALID_SIZE;

			}

			p->setValue(frame, *reinterpret_cast<const *="" double="">(pvalue));</const>

		} else if (TRangeParamP p = param) {

			if (size_in_bytes != sizeof(double) * 2) {

				return TOONZ_ERROR_INVALID_SIZE;

			}

			const double *const pvalues = reinterpret_cast<const *="" double="">(pvalue);</const>

			p->setValue(frame, std::make_pair(pvalues[0], pvalues[1]));

		} else if (TPixelParamP p = param) {

			if (size_in_bytes != sizeof(double) * 4) {

				return TOONZ_ERROR_INVALID_SIZE;

			}

			const double *const pvalues = reinterpret_cast<const *="" double="">(pvalue);</const>

			p->setValueD(frame, TPixelD(pvalues[0], pvalues[1], pvalues[2], pvalues[3]));

		} else if (TPointParamP p = param) {

			if (size_in_bytes != sizeof(double) * 2) {

				return TOONZ_ERROR_INVALID_SIZE;

			}

			const double *const pvalues = reinterpret_cast<const *="" double="">(pvalue);</const>

			p->setValue(frame, TPointD(pvalues[0], pvalues[1]));

		} else if (TIntEnumParamP p = param) {

			if (size_in_bytes != sizeof(int)) {

				return TOONZ_ERROR_INVALID_SIZE;

			}

			p->setValue(*reinterpret_cast<const *="" int="">(pvalue));</const>

		} else if (TIntParamP p = param) {

			if (size_in_bytes != sizeof(int)) {

				return TOONZ_ERROR_INVALID_SIZE;

			}

			p->setValue(*reinterpret_cast<const *="" int="">(pvalue));</const>

		} else if (TBoolParamP p = param) {

			if (size_in_bytes != sizeof(int)) {

				return TOONZ_ERROR_INVALID_SIZE;

			}

			p->setValue(*reinterpret_cast<const *="" int="">(pvalue) != 0);</const>

		} else if (TSpectrumParamP p = param) {

			const double *values = reinterpret_cast<const *="" double="">(pvalue);</const>

			const int count = size_in_bytes / (sizeof(double) * 5);

			std::vector<tspectrum::colorkey> keys(count);</tspectrum::colorkey>

			for (int i = 0; i < count; i++) {

				keys[i].first = values[5 * i + 0];

				keys[i].second = toPixel32(TPixelD(

					values[5 * i + 1], values[5 * i + 2],

					values[5 * i + 3], values[5 * i + 4]));

			}

			p->setValue(frame, TSpectrum(count, keys.data()));

		} else if (TStringParamP p = param) {

			if (size_in_bytes < 1) {

				return TOONZ_ERROR_INVALID_SIZE;

			}

			const char *values = reinterpret_cast<const *="" char="">(pvalue);</const>

			p->setValue(QString::fromStdString(values).toStdWString());

		} else if (TToneCurveParamP p = param) {

			const double *values = reinterpret_cast<const *="" double="">(pvalue);</const>

			const int count = size_in_bytes / (sizeof(double) * 2);

			QList<tpointd> list;</tpointd>

			for (int i = 0; i < count; ++i) {

				list.push_back(TPointD(values[2 * i + 0], values[2 * i + 1]));

			}

			p->setValue(frame, list);

		} else {

			return TOONZ_ERROR_NOT_IMPLEMENTED;

		}

	} else {

		return TOONZ_ERROR_INVALID_HANDLE;

	}

	return TOONZ_OK;

}