#pragma once

#ifndef TOONZ_STDFX_PLUGIN_HOST_H__

#define TOONZ_STDFX_PLUGIN_HOST_H__

#include <qthread></qthread>

#include <string></string>

#include <memory></memory>

#include "tzeraryfx.h"

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

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

#endif

#include "toonz_plugin.h"

#include "toonz_hostif.h"

/*

namespace toonz {

        struct nodal_rasterfx_handler_t;

        struct host_interface_t;

        struct plugin_probe_t;

}

*/

/* probe で得られる静的な plugin 情報 */

class PluginDescription {

public:

  std::string name_;

  std::string vendor_;

  std::string id_;

  std::string note_;

  std::string url_;

  std::string fullname_;

  int clss_;

  toonz_plugin_version_t plugin_ver_;

public:

  PluginDescription(const toonz::plugin_probe_t *const probe);

  /* 'geometric' is known as 'Zerary' on toonz. we avoid using the word because

   * nobody did not understand a meaning of the word */

  bool is_geometric() const {

    return clss_ & TOONZ_PLUGIN_CLASS_MODIFIER_GEOMETRIC;

  }

};

class PluginInformation;

/* エフェクトのインスタンスを構築するためのクラス */

struct PluginDeclaration : public TFxDeclaration {

  PluginDeclaration(PluginInformation *pi);

  TPersist *create() const final override;

private:

  PluginInformation *pi_;

};

class UIPage;

class Param;

class ParamView;

class ParamsPageSet;

struct port_description_t {

  bool input_;

  std::string name_;

  int type_;

public:

  port_description_t(bool input, const char *nm, int type)

      : input_(input), name_(nm), type_(type) {}

};

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

typedef std::shared_ptr<std::remove_pointer<hmodule>::type> library_t;</std::remove_pointer<hmodule>

#else

typedef std::shared_ptr<void> library_t;</void>

#endif

class PluginInformation {

public:

  PluginDeclaration *decl_;

  PluginDescription *desc_;

  library_t library_;

  toonz::nodal_rasterfx_handler_t *handler_;

  toonz::host_interface_t *host_;

  int (*ini_)(toonz::host_interface_t *);

  void (*fin_)(void);

  int ref_count_;

  int param_page_num_;

  std::unique_ptr<toonz_param_page_t[]> param_pages_;</toonz_param_page_t[]>

  std::vector<uipage *=""> ui_pages_;</uipage>

  std::vector<paramview *=""> param_views_;</paramview>

  std::map<std::string, port_description_t=""> port_mapper_;</std::string,>

  std::vector<std::shared_ptr<void>></std::shared_ptr<void>

      param_resources_; /* deep-copy に使う scratch area */

  std::vector<std::shared_ptr<std::string>></std::shared_ptr<std::string>

      param_string_tbl_; /* shared_ptr< void > では non-virtual destructor

                            が呼ばれないので  */

public:

  PluginInformation()

      : desc_(NULL)

      , library_(NULL)

      , handler_(NULL)

      , host_(NULL)

      , ini_(NULL)

      , fin_(NULL)

      , ref_count_(1)

      , param_page_num_(0) {}

  ~PluginInformation();

  void add_ref();

  void release();

};

class Loader : public QObject {

  Q_OBJECT;

public:

  Loader();

protected:

  void doLoad(const QString &file);

  void walkDirectory_(const QString &file);

public slots:

  void walkDirectory(const QString &file);

  void walkDictionary(const QString &file);

signals:

  void load_finished(PluginInformation *pi);

  void fixup();

};

class PluginLoadController : public QObject {

  Q_OBJECT;

  QThread work_entity;

public:

  PluginLoadController(const std::string &basedir, QObject *listener);

  bool wait(int timeout_in_ms) { return work_entity.wait(timeout_in_ms); };

public slots:

  void result(PluginInformation *pi);

  void finished();

signals:

  void start(const QString &filepath);

};

class RasterFxPluginHost : public TZeraryFx, public TPluginInterface {

  PluginInformation *pi_;

  std::vector<std::shared_ptr<tfxport>> inputs_;</std::shared_ptr<tfxport>

  std::vector<std::shared_ptr<param>> params_;</std::shared_ptr<param>

  void *user_data_;

  static bool validateKeyName(const char *name);

protected:

  virtual RasterFxPluginHost *newInstance(PluginInformation *pi) const;

public:

  RasterFxPluginHost(PluginInformation *pinfo);

  ~RasterFxPluginHost();

  void notify();

  const TPersistDeclaration *getDeclaration() const;

  std::string getPluginId() const;

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

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

  int getMemoryRequirement(const TRectD &rect, double frame,

                           const TRenderSettings &info);

  bool canHandle(const TRenderSettings &info, double frame);

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

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

  TFx *clone(bool recursive) const;

  // UIPage

  UIPage *createUIPage(const char *name);

  void build(ParamsPageSet *);

  std::string getUrl() const;

  // setup

  bool setParamStructure(int n, toonz_param_page_t *descs, int &err,

                         void *&pos);

  bool addPortDesc(port_description_t &&);

  Param *createParam(const toonz_param_desc_t *);

  Param *createParam(const char *name, toonz_param_type_enum e);

  Param *getParam(const char *name) const;

  ParamView *createParamView();

  bool isPlugin() const { return true; }

  bool isPluginZerary() const { return pi_->desc_->is_geometric(); }

  bool isZerary() const { return isPluginZerary(); };

  void callStartRenderHandler();

  void callEndRenderHandler();

  void callStartRenderFrameHandler(const TRenderSettings *rs, double frame);

  void callEndRenderFrameHandler(const TRenderSettings *rs, double frame);

  void *getUserData();

  void setUserData(void *user_data);

  void createParamsByDesc();

  void createPortsByDesc();

};

#endif