#include <sstream></sstream>

#include <string></string>

#include <utility></utility>

#include <stdexcept></stdexcept>

#include <stdint.h></stdint.h>

#if defined(_WIN32) || defined(_CYGWIN_)

#define UUID UUID_

#include <windows.h></windows.h>

#undef UUID

#else

#include <dlfcn.h></dlfcn.h>

#endif

#include <string></string>

#include <map></map>

#include <type_traits></type_traits>

#include <functional></functional>

// #include "tfxparam.h"

#include <toonzqt addfxcontextmenu.h=""> // as receiver</toonzqt>

#include "tenv.h"

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

#include "toonz/tcolumnfx.h"

#include "pluginhost.h"

#include "toonz_plugin.h"

#include "toonz_hostif.h"

#include "toonz_params.h"

#include "plugin_tile_interface.h"

#include "plugin_port_interface.h"

#include "plugin_fxnode_interface.h"

#include "plugin_param_interface.h"

#include "plugin_param_view_interface.h"

#include "plugin_ui_page_interface.h"

#include "plugin_utilities.h"

#include "toonz_params.h"

#include <qfileinfo></qfileinfo>

#include <qdir></qdir>

#include <qlabel></qlabel>

#include <qhboxlayout></qhboxlayout>

#include <qformlayout></qformlayout>

//#include <qtconcurrent></qtconcurrent>

#include "plugin_param_traits.h"

#include "../include/toonzqt/pluginloader.h"

using namespace toonz; // plugin namespace

extern std::map<std::string, *="" plugininformation=""> plugin_dict_;</std::string,>

/*

  PluginLoadController が main thread queue を使うことと, 

  QThread で他スレッドの待ち合わせがしにくい(sendor thread が QThread::wait() でブロックしていると emit signal が処理できずデッドロックする)ので、

  大人しく polling にした.

 */

bool PluginLoader::load_entries(const std::string &basepath)

{

	static PluginLoadController *aw = NULL; /* main() から一度だけ呼ばれる */

	if (!aw) {

		aw = new PluginLoadController(basepath, NULL);

	}

	bool ret = aw->wait(16 /* ms */);

	if (ret)

		aw = NULL; /* deleteLater で消えるはず */

	return ret;

}

TFx *PluginLoader::create_host(const std::string &fxId)

{

	std::string id = fxId.substr(5);

	auto it = plugin_dict_.find(id);

	if (it != plugin_dict_.end()) {

		auto plugin = new RasterFxPluginHost(it->second);

		plugin->notify();

		return plugin;

	}

	return NULL;

}

std::map<std::string, *="" qtreewidgetitem=""> PluginLoader::create_menu_items(std::function<void(qtreewidgetitem *)=""> &&l1_handler, std::function<void(qtreewidgetitem *)=""> &&l2_handler)</void(qtreewidgetitem></void(qtreewidgetitem></std::string,>

{

	std::map<std::string, *="" qtreewidgetitem=""> vendors;</std::string,>

	for (auto plugin : plugin_dict_) {

		PluginDescription *desc = plugin.second->desc_;

		if (vendors.count(desc->vendor_) == 0) {

			auto vendor = new QTreeWidgetItem((QTreeWidget *)NULL, QStringList(QString::fromStdString(desc->vendor_)));

			vendors.insert(std::make_pair(desc->vendor_, vendor));

			l1_handler(vendor);

		}

		auto vendor = vendors[desc->vendor_];

		auto item = new QTreeWidgetItem((QTreeWidget *)NULL, QStringList(QString::fromStdString(desc->name_)));

		item->setData(0, Qt::UserRole, QVariant("_plg_" + QString::fromStdString(desc->id_)));

		l2_handler(item);

		vendor->addChild(item);

	}

	return vendors;

}

static bool copy_rendering_setting(toonz_rendering_setting_t *dst, const TRenderSettings &src);

class PluginSetupMessage : public TThread::Message

{

	PluginInformation *pi_;

public:

	PluginSetupMessage(PluginInformation *pi) : pi_(pi) {}

	void onDeliver()

	{

		RasterFxPluginHost *fx = new RasterFxPluginHost(pi_);

		if (pi_ && pi_->handler_) {

			pi_->handler_->setup(fx);

			/* fx は pi のラッパーとしてのみ構築されており、即座に削除される. 実 instance に引き継がれないので ここで createParam() 等を呼び出しても意味がない.

			   ここで createParamsByDesc() などを呼び出しても、 instance の parameter は 0 になる.  */

		}

		delete fx;

	}

	TThread::Message *clone() const

	{

		return new PluginSetupMessage(*this);

	}

};

PluginInformation::~PluginInformation()

{

	if (library_) {

		if (library_.use_count() == 1 && fin_) {

			fin_();

		}

	}

}

void PluginInformation::add_ref()

{

	++ref_count_;

}

void PluginInformation::release()

{

	if (--ref_count_ == 0) {

		delete this;

	}

}

PluginDescription::PluginDescription(const plugin_probe_t *const probe)

{

	name_ = probe->name ? probe->name : "unnamed-plugin";

	vendor_ = probe->vendor ? probe->vendor : "";

	id_ = probe->id ? probe->id : "unnamed-plugin.plugin";

	note_ = probe->note ? probe->note : "";

	url_ = probe->helpurl ? probe->helpurl : "";

	clss_ = probe->clss;

	fullname_ = id_ + "$" + name_ + "$" + vendor_;

	plugin_ver_ = probe->plugin_ver;

}

RasterFxPluginHost::RasterFxPluginHost(PluginInformation *pinfo)

	: TZeraryFx(), pi_(pinfo), user_data_(nullptr)

{

	pi_->add_ref();

}

static int create_param_view(toonz_node_handle_t node, toonz_param_view_handle_t *view)

{

	ParamView *p = NULL;

	try {

		RasterFxPluginHost *fx = reinterpret_cast<rasterfxpluginhost *="">(node);</rasterfxpluginhost>

		if (!fx) {

			printf("create_param_view: invalid toonz_node_handle_t\n");

			return TOONZ_ERROR_INVALID_HANDLE;

		}

		if (p = fx->createParamView()) {

			*view = p;

		} else {

			printf("create_param_view: invalid param name");

			return TOONZ_ERROR_FAILED_TO_CREATE;

		}

	} catch (const std::exception &e) {

		printf("create_param_view: exception: %s\n", e.what());

		delete p;

		return TOONZ_ERROR_UNKNOWN;

	}

	return TOONZ_OK;

}

static int setup_input_port(toonz_node_handle_t node, const char *name, int type)

{

	try {

		RasterFxPluginHost *fx = reinterpret_cast<rasterfxpluginhost *="">(node);</rasterfxpluginhost>

		if (!fx)

			return TOONZ_ERROR_INVALID_HANDLE;

		if (!fx->addPortDesc({true, name, type})) {

			printf("add_input_port: failed to add: already have\n");

			return TOONZ_ERROR_BUSY;

		}

	} catch (const std::exception &e) {

		printf("setup_putput_port: exception: %s\n", e.what());

		return TOONZ_ERROR_UNKNOWN;

	}

	return TOONZ_OK;

}

static int setup_output_port(toonz_node_handle_t node, const char *name, int type)

{

	try {

		RasterFxPluginHost *fx = reinterpret_cast<rasterfxpluginhost *="">(node);</rasterfxpluginhost>

		if (!fx)

			return TOONZ_ERROR_INVALID_HANDLE;

		if (!fx->addPortDesc({false, name, type})) {

			printf("add_input_port: failed to add: already have\n");

			return TOONZ_ERROR_BUSY;

		}

	} catch (const std::exception &e) {

		printf("setup_putput_port: exception: %s\n", e.what());

		return TOONZ_ERROR_UNKNOWN;

	}

	return TOONZ_OK;

}

static int add_input_port(toonz_node_handle_t node, const char *name, int type, toonz_port_handle_t *port)

{

	try {

		RasterFxPluginHost *fx = reinterpret_cast<rasterfxpluginhost *="">(node);</rasterfxpluginhost>

		if (!fx)

			return TOONZ_ERROR_INVALID_HANDLE;

		auto p = std::make_shared<trasterfxport>();</trasterfxport>

		/* TRasterFxPort は non-copyable なスマートポインタなのでポインタで引き回す */

		if (!fx->addInputPort(name, p)) { // overloaded version

			printf("add_input_port: failed to add: already have\n");

			return TOONZ_ERROR_BUSY;

		}

		*port = p.get();

	} catch (const std::exception &e) {

		printf("add_input_port: exception: %s\n", e.what());

		return TOONZ_ERROR_UNKNOWN;

	}

	return TOONZ_OK;

}

static int get_input_port(toonz_node_handle_t node, const char *name, toonz_port_handle_t *port)

{

	if (!(node && port)) {

		return TOONZ_ERROR_NULL;

	}

	RasterFxPluginHost *fx = reinterpret_cast<rasterfxpluginhost *="">(node);</rasterfxpluginhost>

	std::string portName(name);

	TFxPort *tfxport = fx->getInputPort(portName);

	if (!tfxport) {

		return TOONZ_ERROR_NOT_FOUND;

	}

	*port = tfxport;

	return TOONZ_OK;

}

static int add_output_port(toonz_node_handle_t node, const char *name, int type, toonz_port_handle_t *port)

{

	TRasterFxPort *p = NULL;

	try {

		RasterFxPluginHost *fx = reinterpret_cast<rasterfxpluginhost *="">(node);</rasterfxpluginhost>

		if (!fx)

			return TOONZ_ERROR_INVALID_HANDLE;

		p = new TRasterFxPort();

		/* TRasterFxPort は non-copyable なスマートポインタなのでポインタで引き回す */

		if (fx->addOutputPort(name, p)) { // overloaded version

			delete p;

			return TOONZ_ERROR_BUSY;

		}

		*port = p;

	} catch (const std::exception &) {

		delete p;

		return TOONZ_ERROR_UNKNOWN;

	}

	return TOONZ_OK;

}

static int get_rect(toonz_rect_t *rect, double *x0, double *y0, double *x1, double *y1)

{

	if (!(rect && x0 && y0 && x1 && y1)) {

		return -2;

	}

	*x0 = rect->x0;

	*y0 = rect->y0;

	*x1 = rect->x1;

	*y1 = rect->y1;

	return 0;

}

static int set_rect(toonz_rect_t *rect, double x0, double y0, double x1, double y1)

{

	if (!rect) {

		return -2;

	}

	rect->x0 = x0;

	rect->y0 = y0;

	rect->x1 = x1;

	rect->y1 = y1;

	return 0;

}

static int add_preference(toonz_node_handle_t node, const char *name, toonz_ui_page_handle_t *ui)

{

	UIPage *p = NULL;

	try {

		RasterFxPluginHost *fx = reinterpret_cast<rasterfxpluginhost *="">(node);</rasterfxpluginhost>

		if (!fx) {

			printf("add_preference: invalid toonz_node_handle_t\n");

			return TOONZ_ERROR_INVALID_HANDLE;

		}

		if (p = fx->createUIPage(name)) {

			*ui = p;

		} else {

			printf("add_preference: failed to get UIPage\n");

			return TOONZ_ERROR_FAILED_TO_CREATE;

		}

	} catch (const std::exception &e) {

		printf("add_preference: exception: %s\n", e.what());

		delete p;

		return TOONZ_ERROR_UNKNOWN;

	}

	return TOONZ_OK;

}

static int add_param(toonz_node_handle_t node, const char *name, int type, toonz_param_handle_t *param)

{

	Param *p = NULL;

	try {

		RasterFxPluginHost *fx = reinterpret_cast<rasterfxpluginhost *="">(node);</rasterfxpluginhost>

		if (!fx) {

			printf("add_param: invalid toonz_node_handle_t\n");

			return TOONZ_ERROR_INVALID_HANDLE;

		}

		if (p = fx->createParam(name, toonz_param_type_enum(type))) {

			*param = p;

		} else {

			printf("add_param: invalid type");

			return TOONZ_ERROR_FAILED_TO_CREATE;

		}

	} catch (const std::exception &e) {

		printf("add_param: exception: %s\n", e.what());

		delete p;

		return TOONZ_ERROR_UNKNOWN;

	}

	return TOONZ_OK;

}

static int get_param(toonz_node_handle_t node, const char *name, toonz_param_handle_t *param)

{

	try {

		RasterFxPluginHost *fx = reinterpret_cast<rasterfxpluginhost *="">(node);</rasterfxpluginhost>

		if (!fx) {

			printf("get_param: invalid toonz_node_handle_t\n");

			return TOONZ_ERROR_INVALID_HANDLE;

		}

		if (Param *p = fx->getParam(name)) {

			*param = p;

		} else {

			printf("get_param: invalid type");

			return TOONZ_ERROR_NOT_FOUND;

		}

	} catch (const std::exception&) {

	}

	return TOONZ_OK;

}

static int set_user_data(toonz_node_handle_t node, void *user_data)

{

	if (!node) {

		return TOONZ_ERROR_NULL;

	}

	RasterFxPluginHost *fx = reinterpret_cast<rasterfxpluginhost *="">(node);</rasterfxpluginhost>

	fx->setUserData(user_data);

	return TOONZ_OK;

}

static int get_user_data(toonz_node_handle_t node, void **user_data)

{

	if (!node || !user_data) {

		return TOONZ_ERROR_NULL;

	}

	RasterFxPluginHost *fx = reinterpret_cast<rasterfxpluginhost *="">(node);</rasterfxpluginhost>

	*user_data = fx->getUserData();

	return TOONZ_OK;

}

bool RasterFxPluginHost::addPortDesc(port_description_t &&desc)

{

	printf("addPortDesc: name:%s dir:%d type:%d\n", desc.name_.c_str(), desc.input_, desc.type_);

	auto ret = pi_->port_mapper_.insert(std::make_pair(desc.name_, desc));

	return ret.second;

}

void RasterFxPluginHost::notify()

{

	/* 最低限必要な setup をしてから通知する */

	QString nm = QString::fromStdString(pi_->desc_->name_.c_str());

	setName(nm.toStdWString());

	createParamsByDesc();

	createPortsByDesc();

	if (pi_ && pi_->handler_->create)

		pi_->handler_->create(this);

}

RasterFxPluginHost::~RasterFxPluginHost()

{

	if (pi_ && pi_->handler_->destroy) {

		pi_->handler_->destroy(this);

		pi_->release();

	}

	inputs_.clear();

}

/*

 node を click するなどの要因で頻繁に呼ばれる.

 click した場合は FxsData::setFxs から呼ばれ、新しいインスタンスは FxsData::m_fxs に入れられ、 FxsData のインスタンスと同時に(大抵の場合は)即座に消される.

 */

TFx *RasterFxPluginHost::clone(bool recursive) const

{

	RasterFxPluginHost *plugin = newInstance(pi_);

	plugin->user_data_ = user_data_;

	// clone ports before TFx::clone().

	for (auto &ip : pi_->port_mapper_) {

		if (ip.second.input_) {

#if 0

			/* addInputPort() 内で行われる port owner の更新は後勝ちだが,

			   clone された新しいインスタンスのほうが先に消えてしまう場合に, 無効なポインタを示す owner が port に残ってしまう. この問題が解決したら共有できるようにしたい.

			   (このため、 plugin 空間に通知される全ての handle には一貫性がない. ただし、後から一貫性がなくなるよりは遥かにいいだろう)

			*/

			plugin->addInputPort(getInputPortName(i), ip);

#else

			plugin->addInputPort(ip.first, std::shared_ptr<tfxport>(new TRasterFxPort));</tfxport>

#endif

		}

	}

	printf("recursive:%d params:%d\n", recursive, params_.size());

	// clone params before TFx::clone().

	/* ui_pages_, param_views_ は pi に移ったが createParam の呼び出しだけはしておかないと Fx Settings 構築時に assert failed になる */

	for (auto const ¶m : params_) {

		/* 古い createParam() は desc をとらず、コンストラクト時にデフォルト値を持つタイプの T*Param を再作成できない */

		plugin->createParam(param->desc());

	}

	return TFx::clone(plugin, recursive);

}

RasterFxPluginHost *RasterFxPluginHost::newInstance(PluginInformation *pi) const

{

	return new RasterFxPluginHost(pi);

}

const TPersistDeclaration *RasterFxPluginHost::getDeclaration() const

{

	printf("RasterFxPluginHost::getDeclaration()\n");

	return pi_->decl_;

}

PluginDeclaration::PluginDeclaration(PluginInformation *pi)

	: TFxDeclaration(TFxInfo(pi->desc_->id_, false)), pi_(pi)

{

}

TPersist *PluginDeclaration::create() const

{

	RasterFxPluginHost *fx = new RasterFxPluginHost(pi_);

	fx->notify();

	return fx;

}

std::string RasterFxPluginHost::getPluginId() const { return pi_->desc_->id_; };

void *RasterFxPluginHost::getUserData()

{

	return user_data_;

}

void RasterFxPluginHost::setUserData(void *user_data)

{

	user_data_ = user_data;

}

bool RasterFxPluginHost::doGetBBox(double frame, TRectD &bbox, const TRenderSettings &info)

{

	using namespace plugin::utils;

	bool ret = true; /* 負論理 */

	if (pi_ && pi_->handler_->do_get_bbox) {

		rendering_setting_t info_;

		copy_rendering_setting(&info_, info);

		rect_t rc;

		copy_rect(&rc, bbox);

		ret = ret && pi_->handler_->do_get_bbox(this, &info_, frame, &rc);

		bbox = restore_rect(&rc);

	}

	return !ret;

}

void RasterFxPluginHost::doCompute(TTile &tile, double frame, const TRenderSettings &info)

{

	if (pi_ && pi_->handler_->do_compute) {

		rendering_setting_t info_;

		copy_rendering_setting(&info_, info);

		pi_->handler_->do_compute(this, &info_, frame, &tile);

	}

}

int RasterFxPluginHost::getMemoryRequirement(const TRectD &rect, double frame, const TRenderSettings &info)

{

	using namespace plugin::utils;

	if (pi_ && pi_->handler_->get_memory_requirement) {

		rendering_setting_t rs;

		copy_rendering_setting(&rs, info);

		rect_t rc;

		copy_rect(&rc, rect);

		size_t ignore = pi_->handler_->get_memory_requirement(this, &rs, frame, &rc);

		return 0;

	}

	return 0;

}

bool RasterFxPluginHost::canHandle(const TRenderSettings &info, double frame)

{

	if (pi_ && pi_->handler_->can_handle) {

		rendering_setting_t rs;

		copy_rendering_setting(&rs, info);

		return pi_->handler_->can_handle(this, &rs, frame);

	}

	/* 適切なデフォルト値は 'geometric' の場合とそうでない場合で異なる */

	return isPluginZerary(); /* better-default depends on that is 'geometric' or not */

}

bool RasterFxPluginHost::addInputPort(const std::string &nm, std::shared_ptr<tfxport> port)</tfxport>

{

	/* setOwnFx は addInputPort 内で行われている. setFx() は接続なので自分自身に呼んではダメ */

	//port->setFx(this);

	bool ret = TFx::addInputPort(nm, *port.get());

	if (ret) {

		inputs_.push_back(port);

	}

	return ret;

}

bool RasterFxPluginHost::addOutputPort(const std::string &nm, TRasterFxPort *port)

{

	port->setFx(this);

	return TFx::addOutputConnection(port);

}

void RasterFxPluginHost::callStartRenderHandler()

{

	if (pi_ && pi_->handler_ && pi_->handler_->start_render) {

		pi_->handler_->start_render(this);

	}

}

void RasterFxPluginHost::callEndRenderHandler()

{

	if (pi_ && pi_->handler_ && pi_->handler_->end_render) {

		pi_->handler_->end_render(this);

	}

}

void RasterFxPluginHost::callStartRenderFrameHandler(const TRenderSettings *rs, double frame)

{

	toonz_rendering_setting_t trs;

	copy_rendering_setting(&trs, *rs);

	if (pi_ && pi_->handler_ && pi_->handler_->on_new_frame) {

		pi_->handler_->on_new_frame(this, &trs, frame);

	}

}

void RasterFxPluginHost::callEndRenderFrameHandler(const TRenderSettings *rs, double frame)

{

	toonz_rendering_setting_t trs;

	copy_rendering_setting(&trs, *rs);

	if (pi_ && pi_->handler_ && pi_->handler_->on_end_frame) {

		pi_->handler_->on_end_frame(this, &trs, frame);

	}

}

std::string RasterFxPluginHost::getUrl() const

{

	return pi_->desc_->url_;

}

UIPage *RasterFxPluginHost::createUIPage(const char *name)

{

	pi_->ui_pages_.push_back(NULL);

	pi_->ui_pages_.back() = new UIPage(name);

	return pi_->ui_pages_.back();

}

// deprecated. for migration.

Param *RasterFxPluginHost::createParam(const char *name, toonz_param_type_enum e)

{

	toonz_param_desc_t *desc = new toonz_param_desc_t;

	memset(desc, 0, sizeof(toonz_param_desc_t));

	desc->base.ver = {1, 0};

	desc->key = name;

	desc->traits_tag = e;

	return createParam(desc);

}

Param *RasterFxPluginHost::createParam(const toonz_param_desc_t *desc)

{

	TParamP p = parameter_factory(desc);

	if (!p)

		return nullptr;

	p->setDescription(desc->note);

	p->setUILabel(desc->base.label);

	bindParam(this, desc->key, p);

	params_.push_back(std::make_shared<param>(this, desc->key, toonz_param_type_enum(desc->traits_tag), desc));

	return params_.back().get();

}

Param *RasterFxPluginHost::getParam(const char *name) const

{

	for (auto ¶m : params_) {

		if (param->name() == name) {

			return param.get();

		}

	}

	return nullptr;

}

ParamView *RasterFxPluginHost::createParamView()

{

	pi_->param_views_.push_back(NULL);

	pi_->param_views_.back() = new ParamView();

	return pi_->param_views_.back();

}

/* build で構築された GUI は plugin のインスタンスには紐づかない. 通常一度だけ呼ばれ使い回される.  */

void RasterFxPluginHost::build(ParamsPageSet *pages)

{

	printf(">>>> RasterFxPluginHost::build: ui_pages:%d\n", pi_->ui_pages_.size());

	for (std::size_t i = 0, size = pi_->ui_pages_.size(); i < size; ++i) {

		pi_->ui_pages_[i]->build(this, pages);

	}

	auto aboutpage = pages->createParamsPage();

#if 1

	/* FIXME: fxsettings で大きさの測定のためにいろいろやっているので使える layout/widget に制限がありそう.

	   しかしなぜか最後の widget しか出ない */

	aboutpage->beginGroup("Name");

	aboutpage->addWidget(new QLabel(pi_->desc_->name_.c_str(), aboutpage));

	aboutpage->endGroup();

	aboutpage->beginGroup("Vendor");

	aboutpage->addWidget(new QLabel(pi_->desc_->vendor_.c_str(), aboutpage));

	aboutpage->endGroup();

	aboutpage->beginGroup("Version");

	auto version =

		QString::fromStdString(std::to_string(pi_->desc_->plugin_ver_.major)) + "." +

		QString::fromStdString(std::to_string(pi_->desc_->plugin_ver_.minor));

	aboutpage->addWidget(new QLabel(version, aboutpage));

	aboutpage->endGroup();

	aboutpage->beginGroup("Note");

	aboutpage->addWidget(new QLabel(pi_->desc_->note_.c_str()), aboutpage);

	aboutpage->endGroup();

#endif

	pages->addParamsPage(aboutpage, "Version");

	aboutpage->setPageSpace();

}

template <typename compat_maj,="" compat_min="" t,="" uint32_t=""></typename>

static inline bool is_compatible(const T &d)

{

	return d.ver.major == compat_maj && d.ver.minor == compat_min;

}

template <uint32_t compat_maj,="" compat_min="" uint32_t=""></uint32_t>

static inline bool is_compatible(const toonz_if_version_t &v)

{

	return v.major == compat_maj && v.minor == compat_min;

}

int check_base_sanity(const toonz_param_page_t *p)

{

	int err = 0;

	if (!is_compatible<toonz_param_base_t_, 0="" 1,="">(p->base))</toonz_param_base_t_,>

		err |= TOONZ_PARAM_ERROR_VERSION;

	if (p->base.label == NULL)

		err |= TOONZ_PARAM_ERROR_LABEL;

	if (p->base.type != TOONZ_PARAM_DESC_TYPE_PAGE)

		err |= TOONZ_PARAM_ERROR_TYPE;

	return err;

}

int check_base_sanity(const toonz_param_group_t *p)

{

	int err = 0;

	if (!is_compatible<toonz_param_base_t_, 0="" 1,="">(p->base))</toonz_param_base_t_,>

		err |= TOONZ_PARAM_ERROR_VERSION;

	if (p->base.label == NULL)

		err |= TOONZ_PARAM_ERROR_LABEL;

	if (p->base.type != TOONZ_PARAM_DESC_TYPE_GROUP)

		err |= TOONZ_PARAM_ERROR_TYPE;

	return err;

}

int check_base_sanity(const toonz_param_desc_t *p)

{

	int err = 0;

	if (!is_compatible<toonz_param_base_t_, 0="" 1,="">(p->base))</toonz_param_base_t_,>

		err |= TOONZ_PARAM_ERROR_VERSION;

	if (p->base.label == NULL)

		err |= TOONZ_PARAM_ERROR_LABEL;

	if (p->base.type != TOONZ_PARAM_DESC_TYPE_PARAM)

		err |= TOONZ_PARAM_ERROR_TYPE;

	return err;

}

bool RasterFxPluginHost::setParamStructure(int n, toonz_param_page_t *p, int &err, void *&pos)

{

	/* 適当に現実的な最大値: あまりに大きい場合は領域の破壊を疑う */

	static const int max_pages_ = 31;

	static const int max_groups_ = 32;

	static const int max_params_ = 65535;

	pos = p;

	if (pi_) {

		if (n > max_pages_ || p == NULL) {

			/* parameter が null でないことは上位でチェックされているはずで、ここで返せるエラーは定義していない. */

			if (p == NULL)

				err |= TOONZ_PARAM_ERROR_UNKNOWN;

			err |= TOONZ_PARAM_ERROR_PAGE_NUM;

			return false;

		}

		/* SAN 値チェック */

		for (int k = 0; k < n; k++) {

			toonz_param_page_t *pg = &p[k];

			pos = pg;

			if (int e = check_base_sanity(pg)) {

				err = e;

				return false;

			}

			if (pg->num > max_groups_) {

				err |= TOONZ_PARAM_ERROR_GROUP_NUM;

				return false;

			}

			for (int l = 0; l < pg->num; l++) {

				toonz_param_group_t *grp = &pg->array[l];

				pos = grp;

				if (int e = check_base_sanity(grp)) {

					err = e;

					return false;

				}

				if (grp->num > max_params_) {

					err |= TOONZ_PARAM_ERROR_GROUP_NUM;

					return false;

				}

				for (int i = 0; i < grp->num; i++) {

					toonz_param_desc_t *desc = &grp->array[i];

					pos = desc;

					if (int e = check_base_sanity(desc))

						err |= e;

					if (desc->key == NULL)

						err |= TOONZ_PARAM_ERROR_NO_KEY;

					else {

						if (!validateKeyName(desc->key))

							err |= TOONZ_PARAM_ERROR_KEY_NAME;

						for (auto it : params_) {

							if (it->name() == desc->key) {

								err |= TOONZ_PARAM_ERROR_KEY_DUP;

								break;

							}

						}

					}

					if (desc->reserved_[0] || desc->reserved_[1]) // reserved fields must be zero

						err |= TOONZ_PARAM_ERROR_POLLUTED;

					err |= check_traits_sanity(desc);

					if (err)

						return false;

				}

			}

		}

		if (err)

			return false;

		// deep copy param resources

		std::vector<std::shared_ptr<void>> ¶m_resources = pi_->param_resources_;</std::shared_ptr<void>

		std::vector<std::shared_ptr<std::string>> &strtbl = pi_->param_string_tbl_;</std::shared_ptr<std::string>

		auto patch_string = [&](const char *srcstr) {

			strtbl.push_back(std::shared_ptr<std::string>(new std::string("")));</std::string>

			if (srcstr)

				strtbl.back()->assign(srcstr);

			return strtbl.back()->c_str();

		};

		auto deep_copy_base = [&](toonz_param_base_t_ &dst, const toonz_param_base_t_ &src) {

			dst.ver = src.ver;

			dst.type = src.type;

			dst.label = patch_string(src.label);

		};

		param_resources.clear();

		std::unique_ptr<toonz_param_page_t[]> origin_pages(new toonz_param_page_t[n]);</toonz_param_page_t[]>

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

			toonz_param_page_t &dst_page = origin_pages[i];

			const toonz_param_page_t &src_page = p[i];

			deep_copy_base(dst_page.base, src_page.base);

			const int group_num = dst_page.num = src_page.num;

			dst_page.array = new toonz_param_group_t[group_num];

			for (int j = 0; j < group_num; j++) {

				toonz_param_group_t &dst_group = dst_page.array[j];

				const toonz_param_group_t &src_group = src_page.array[j];

				deep_copy_base(dst_group.base, src_group.base);

				const int desc_num = dst_group.num = src_group.num;

				dst_group.array = new toonz_param_desc_t[desc_num];

				for (int k = 0; k < desc_num; k++) {

					toonz_param_desc_t &dst_desc = dst_group.array[k];

					const toonz_param_desc_t &src_desc = src_group.array[k];

					deep_copy_base(dst_desc.base, src_desc.base); // base

					dst_desc.key = patch_string(src_desc.key);									// key

					dst_desc.note = patch_string(src_desc.note);								// note

					memcpy(dst_desc.reserved_, src_desc.reserved_, sizeof(src_desc.reserved_)); // reserved fields

					dst_desc.traits_tag = src_desc.traits_tag;									// tag

					// traits

					if (dst_desc.traits_tag == TOONZ_PARAM_TYPE_ENUM) {

						dst_desc.traits.e.def = src_desc.traits.e.def;

						int enums = dst_desc.traits.e.enums = src_desc.traits.e.enums;

						auto a = std::shared_ptr<void>(new char *[enums]);</void>

						param_resources.push_back(a);

						dst_desc.traits.e.array = static_cast<const **="" char="">(a.get());</const>

						for (int i = 0; i < enums; i++)

							dst_desc.traits.e.array[i] = patch_string(src_desc.traits.e.array[i]);

					} else if (dst_desc.traits_tag == TOONZ_PARAM_TYPE_SPECTRUM) {

						int points = dst_desc.traits.g.points = src_desc.traits.g.points;

						auto ptr = std::shared_ptr<void>(new toonz_param_traits_spectrum_t::valuetype[points]);</void>

						param_resources.push_back(ptr);

						dst_desc.traits.g.array = static_cast<toonz_param_traits_spectrum_t::valuetype *="">(ptr.get());</toonz_param_traits_spectrum_t::valuetype>

						for (int i = 0; i < dst_desc.traits.g.points; i++)

							memcpy(&dst_desc.traits.g.array[i], &src_desc.traits.g.array[i], sizeof(toonz_param_traits_spectrum_t::valuetype));

					} else if (dst_desc.traits_tag == TOONZ_PARAM_TYPE_STRING) {

						dst_desc.traits.s.def = patch_string(src_desc.traits.s.def);

					} else if (dst_desc.traits_tag == TOONZ_PARAM_TYPE_TONECURVE) {

						/* has no default values */

					} else {

						memcpy(&dst_desc.traits, &src_desc.traits, sizeof(src_desc.traits));

					}

				}

			}

		}

		pi_->param_page_num_ = n;

		pi_->param_pages_ = std::move(origin_pages);

		return true;

	}

	return false;