#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 <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 <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::string,>

    std::function<void(qtreewidgetitem *)=""> &&l1_handler,</void(qtreewidgetitem>

    std::function<void(qtreewidgetitem *)=""> &&l2_handler) {</void(qtreewidgetitem>

  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 final : public TThread::Message {

  PluginInformation *pi_;

public:

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

  void onDeliver() override {

    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 override {

    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", (int)recursive, (int)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);

  bindPluginParam(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",

         (int)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;

}

static 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;

}

static 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;

}

static 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(</toonz_param_page_t[]>

        new toonz_param_page_t[n]);

    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>(</void>

                new toonz_param_traits_spectrum_t::valuetype[points]);

            param_resources.push_back(ptr);

            dst_desc.traits.g.array =

                static_cast<toonz_param_traits_spectrum_t::valuetype *="">(</toonz_param_traits_spectrum_t::valuetype>

                    ptr.get());

            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;

}

void RasterFxPluginHost::createParamsByDesc() {

  printf("RasterFxPluginHost::createParamsByDesc: num:%d\n",

         pi_->param_page_num_);

  for (int k = 0; k < pi_->param_page_num_; k++) {

    toonz_param_page_t *pg = &pi_->param_pages_[k];

    void *page             = NULL;

    int r                  = add_preference(this, pg->base.label, &page);

    printf(

        "RasterFxPluginHost::createParamsByDesc: add_preference: r:0x%x "

        "page:%p\n",

        r, page);

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

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

      begin_group(page, grp->base.label);

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

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

        Param *p                 = createParam(desc);

        printf("RasterFxPluginHost::createParam: p:%p key:%s tag:%d\n", p,

               desc->key, desc->traits_tag);