#pragma once

#if !defined(TOONZ_PLUGIN_PARAM_TRAITS_H__)
#define TOONZ_PLUGIN_PARAM_TRAITS_H__

#include <toonz_params.h>
#include <functional>

template <typename First, typename Second>
struct param_bind_t {
  typedef First traittype;
  typedef Second realtype;
  typedef typename std::is_compound<typename First::valuetype>::value_type
      complextype;
  typedef typename First::valuetype valuetype;
  static const int RANGED       = First::RANGED;
  static const size_t valuesize = sizeof(typename First::valuetype);
};

typedef param_bind_t<toonz_param_traits_double_t, TDoubleParam> tpbind_dbl_t;
typedef param_bind_t<toonz_param_traits_range_t, TRangeParam> tpbind_rng_t;
typedef param_bind_t<toonz_param_traits_color_t, TPixelParam> tpbind_col_t;
typedef param_bind_t<toonz_param_traits_point_t, TPointParam> tpbind_pnt_t;
typedef param_bind_t<toonz_param_traits_enum_t, TIntEnumParam> tpbind_enm_t;
typedef param_bind_t<toonz_param_traits_int_t, TIntParam> tpbind_int_t;
typedef param_bind_t<toonz_param_traits_bool_t, TBoolParam> tpbind_bool_t;
typedef param_bind_t<toonz_param_traits_spectrum_t, TSpectrumParam>
    tpbind_spc_t;
typedef param_bind_t<toonz_param_traits_string_t, TStringParam> tpbind_str_t;
typedef param_bind_t<toonz_param_traits_tonecurve_t, TToneCurveParam>
    tpbind_tcv_t;

template <typename T>
inline bool is_type_of(const toonz_param_desc_t *desc) {
  if (desc->traits_tag == T::E) return true;
  return false;
}

/* Complex なパラメータは直接 setRangeValue()
 * などを持たず、集約しているサブタイプを返すものがあるので、そのサブタイプを得る関数を取得する
 */
template <typename RT, typename F = TDoubleParamP>
inline F &get_func_a(RT *t) {
  assert(false);
}
template <typename RT, typename F = TDoubleParamP>
inline F &get_func_b(RT *t) {
  assert(false);
}

/* TRangeParam */
template <>
inline TDoubleParamP &get_func_a<TRangeParam, TDoubleParamP>(TRangeParam *t) {
  printf("get_func_a< TRangeParam, TDoubleParamP& >(TRangeParam* t)\n");
  return std::mem_fun(&TRangeParam::getMin)(t);
}

template <>
inline TDoubleParamP &get_func_b<TRangeParam, TDoubleParamP>(TRangeParam *t)
// template<> std::mem_fun_ref_t< TDoubleParamP&, TRangeParam > get_func_b<
// TRangeParam, std::mem_fun_ref_t< TDoubleParamP&, TRangeParam > >(TRangeParam*
// t)
{
  printf("get_func_b< TRangeParam, TDoubleParamP& >(TRangeParam* t)\n");
  return std::mem_fun(&TRangeParam::getMax)(t);
}

/* TPointParam */
template <>
inline TDoubleParamP &get_func_a<TPointParam, TDoubleParamP>(TPointParam *t)
// template<> std::mem_fun_ref_t< TDoubleParamP&, TPointParam > get_func_a<
// TPointParam, std::mem_fun_ref_t< TDoubleParamP&, TPointParam > >(TPointParam*
// t)
{
  printf("get_func_a< TPointParam, TDoubleParamP& >(TPointParam* t)\n");
  return std::mem_fun(&TPointParam::getX)(t);
}

template <>
inline TDoubleParamP &get_func_b<TPointParam, TDoubleParamP>(TPointParam *t)
// template<> std::mem_fun_ref_t< TDoubleParamP&, TPointParam > get_func_b<
// TPointParam, std::mem_fun_ref_t< TDoubleParamP&, TPointParam > >(TPointParam*
// t)
{
  printf("get_func_b< TPointParam, TDoubleParamP& >(TPointParam* t)\n");
  return std::mem_fun(&TPointParam::getY)(t);
}

/* valuetype が集約型の場合、 スカラを取得するための関数 */
template <typename T, typename V>
inline V get_1st_value(const T &) {}
template <typename T, typename V>
inline V get_2nd_value(const T &) {}

template <>
inline double get_1st_value(const toonz_param_traits_range_t::valuetype &r) {
  return r.a;
}
template <>
inline double get_2nd_value(const toonz_param_traits_range_t::valuetype &r) {
  return r.b;
}

template <>
inline double get_1st_value(const toonz_param_traits_point_t::valuetype &p) {
  return p.x;
}
template <>
inline double get_2nd_value(const toonz_param_traits_point_t::valuetype &p) {
  return p.y;
}

template <typename Bind,
          typename Comp =
              typename std::is_compound<typename Bind::valuetype>::type,
          int Ranged = Bind::RANGED>
// template < int Ranged, typename Comp, typename Bind >
struct set_param_range_t {
  static bool set_param_range(Param *param, const toonz_param_desc_t *desc) {
    /* 範囲を持たない(Ranged == std::false_type)なら何もすることはない */
    printf("(none)set_param_range: p:%p type:%s (Comp:%s Ranged:%d)\n", param,
           typeid(Bind).name(), typeid(Comp).name(), Ranged);
    return false;
  }
};

// static_assert(std::is_compound< const char* >(), "false");

/* ranged complextype */
template <typename Bind>
struct set_param_range_t<Bind, std::true_type, 1> {
  static bool set_param_range(Param *param, const toonz_param_desc_t *desc) {
    auto smartptr = param->param();
    typename Bind::realtype *p =
        reinterpret_cast<typename Bind::realtype *>(smartptr.getPointer());
    if (p) {
      const typename Bind::traittype &t =
          *reinterpret_cast<const typename Bind::traittype *>(&desc->traits.d);
      auto subtype_a = get_func_a<typename Bind::realtype>(p);
      auto subtype_b = get_func_b<typename Bind::realtype>(p);
      auto a_minval  = get_1st_value<typename Bind::valuetype, double>(t.min);
      auto a_maxval  = get_2nd_value<typename Bind::valuetype, double>(t.min);
      auto b_minval  = get_1st_value<typename Bind::valuetype, double>(t.max);
      auto b_maxval  = get_2nd_value<typename Bind::valuetype, double>(t.max);
      printf("a->set_param_range: (%g, %g)\n", a_minval, a_maxval);
      printf("b->set_param_range: (%g, %g)\n", b_minval, b_maxval);
      (subtype_a)->setValueRange(a_minval, a_maxval);
      (subtype_b)->setValueRange(b_minval, b_maxval);
    }
    return true;
  }
};

/* range
   のとき、スライダの左と右それぞれに限界が設定できるように見えるが、そうではない.
   getMin(), getMax() の結果それぞれに range を設定できるように見えて
   実際は getMin() には (min, max) のうち min, getMax() には (min, max) のうち
   max しか有効でないように見える.
   このため range に対しても特殊版を用意するハメになった. */
template <>
struct set_param_range_t<tpbind_rng_t, std::true_type, 1> {
  static bool set_param_range(Param *param, const toonz_param_desc_t *desc) {
    auto smartptr = param->param();
    tpbind_rng_t::realtype *p =
        reinterpret_cast<tpbind_rng_t::realtype *>(smartptr.getPointer());
    if (p) {
      const tpbind_rng_t::traittype &t = desc->traits.rd;
      auto subtype_a                   = get_func_a<tpbind_rng_t::realtype>(p);
      auto subtype_b                   = get_func_b<tpbind_rng_t::realtype>(p);
      auto a_minval = get_1st_value<tpbind_rng_t::valuetype, double>(t.minmax);
      auto a_maxval = get_2nd_value<tpbind_rng_t::valuetype, double>(t.minmax);
      (subtype_a)->setValueRange(a_minval, a_maxval);
      (subtype_b)->setValueRange(a_minval, a_maxval);
    }
    return true;
  }
};

/*
template <>
struct set_param_range_t< tpbind_pnt_t, std::true_type, 1 >  {
        static bool set_param_range(Param* param, const toonz_param_desc_t*
desc)
        {
                auto smartptr = param->param();
                tpbind_pnt_t::realtype* p = reinterpret_cast<
tpbind_pnt_t::realtype* >(smartptr.getPointer());
                if (p) {
                        const tpbind_pnt_t::traittype& t = *reinterpret_cast<
const tpbind_pnt_t::traittype* >(&desc->traits.d);
                        auto subtype_a = get_func_a< tpbind_pnt_t::realtype
>(p);
                        auto subtype_b = get_func_b< tpbind_pnt_t::realtype
>(p);
                        auto a_minval = get_1st_value< tpbind_pnt_t::valuetype,
double >(t.min);
                        auto a_maxval = get_2nd_value< tpbind_pnt_t::valuetype,
double >(t.min);
                        auto b_minval = get_1st_value< tpbind_pnt_t::valuetype,
double >(t.max);
                        auto b_maxval = get_2nd_value< tpbind_pnt_t::valuetype,
double >(t.max);
                        printf("a->set_param_range: pnt(%g, %g)\n", a_minval,
a_maxval);
                        printf("b->set_param_range: pnt(%g, %g)\n", b_minval,
b_maxval);
                        (subtype_a)->setValueRange(a_minval, a_maxval);
                        (subtype_b)->setValueRange(b_minval, b_maxval);
                }
                return true;
        }
};
*/

/* ranged primitive: */
template <typename Bind>
struct set_param_range_t<Bind, std::false_type, 1> {
  static bool set_param_range(Param *param, const toonz_param_desc_t *desc) {
    if (!is_type_of<typename Bind::traittype>(desc)) return false;
    auto smartptr = param->param();
    typename Bind::realtype *p =
        reinterpret_cast<typename Bind::realtype *>(smartptr.getPointer());
    if (p) {
      const typename Bind::traittype &t =
          *reinterpret_cast<const typename Bind::traittype *>(&desc->traits.d);
      printf("p(%p)->set_param_range: typeid:%s desc:%p (%p)\n", p,
             typeid(typename Bind::traittype).name(), desc, &desc->traits.d);
      p->setValueRange(t.min, t.max);
    }
    return true;
  }
};

template <typename Bind>
bool set_param_range(Param *param, const toonz_param_desc_t *desc) {
  if (!is_type_of<typename Bind::traittype>(desc)) return false;
  return set_param_range_t<Bind>::set_param_range(param, desc);
}

template <typename Bind,
          typename Comp =
              typename std::is_compound<typename Bind::valuetype>::type>
struct set_param_default_t {
  static bool set_param_default(Param *param, const toonz_param_desc_t *desc) {
    return false;
  }
};

/* Default complextype */
/* Point/Range */
template <typename Bind>
struct set_param_default_t<Bind, std::true_type> {
  static bool set_param_default(Param *param, const toonz_param_desc_t *desc) {
    auto smartptr = param->param();
    typename Bind::realtype *p =
        reinterpret_cast<typename Bind::realtype *>(smartptr.getPointer());
    if (p) {
      const typename Bind::traittype &t =
          *reinterpret_cast<const typename Bind::traittype *>(&desc->traits.d);
      auto subtype_a = get_func_a<typename Bind::realtype>(p);
      auto subtype_b = get_func_b<typename Bind::realtype>(p);
      auto a_defval  = get_1st_value<typename Bind::valuetype, double>(t.def);
      auto b_defval  = get_2nd_value<typename Bind::valuetype, double>(t.def);
      printf("a->set_param_default: double (%g, %g)\n", a_defval, b_defval);
      (subtype_a)->setDefaultValue(a_defval);
      (subtype_b)->setDefaultValue(b_defval);
    }
    return true;
  }
};

/* Default Color */
template <>
struct set_param_default_t<tpbind_col_t, std::true_type> {
  static bool set_param_default(Param *param, const toonz_param_desc_t *desc) {
    auto smartptr = param->param();
    tpbind_col_t::realtype *p =
        reinterpret_cast<tpbind_col_t::realtype *>(smartptr.getPointer());
    if (p) {
      const tpbind_col_t::traittype &t =
          *reinterpret_cast<const tpbind_col_t::traittype *>(&desc->traits.d);
      p->setDefaultValue(TPixel32(t.def.c0, t.def.c1, t.def.c2, t.def.m));
    }
    return true;
  }
};

/* Default String */
template <>
struct set_param_default_t<tpbind_str_t, std::true_type> {
  static bool set_param_default(Param *param, const toonz_param_desc_t *desc) {
    auto smartptr = param->param();
    tpbind_str_t::realtype *p =
        reinterpret_cast<tpbind_str_t::realtype *>(smartptr.getPointer());
    if (p) {
      const tpbind_str_t::traittype &t =
          *reinterpret_cast<const tpbind_str_t::traittype *>(&desc->traits.d);
      printf("a->set_param_default: str\n");
      std::wstring wstr = QString::fromStdString(t.def).toStdWString();
      p->setDefaultValue(wstr);
      p->setValue(wstr, false);
    }
    return true;
  }
};

/* Default Spectrum */
template <>
struct set_param_default_t<tpbind_spc_t, std::true_type> {
  static bool set_param_default(Param *param, const toonz_param_desc_t *desc) {
    /* unfortunatly, TSpectrumParam's default values must be set within the
     constructor, for now.
     see param_factory_< TSpectrumParam >() */
    return false;
  }
};

/* Default ToneCurve */
template <>
struct set_param_default_t<tpbind_tcv_t, std::true_type> {
  static bool set_param_default(Param *param, const toonz_param_desc_t *desc) {
    /*
    auto smartptr = param->param();
    tpbind_tcv_t::realtype* p = reinterpret_cast< tpbind_tcv_t::realtype*
    >(smartptr.getPointer());
    if (p) {
            const tpbind_tcv_t::traittype& t = *reinterpret_cast< const
    tpbind_tcv_t::traittype* >(&desc->traits.d);
            printf("a->set_param_default: spec\n");
            QList< TPointD > pt;
            for (int i = 0; i < t.cps; i ++) {
                    pt.push_back(TPointD(t.array[i].x, t.array[i].y));
            }
            p->setDefaultValue(pt);
            p->setIsLinear(!(t.intep));
            }*/
    return true;
  }
};

/* primitive: TDoubleParam */
template <>
struct set_param_default_t<tpbind_dbl_t, std::false_type> {
  static bool set_param_default(Param *param, const toonz_param_desc_t *desc) {
    auto smartptr = param->param();
    tpbind_dbl_t::realtype *p =
        reinterpret_cast<tpbind_dbl_t::realtype *>(smartptr.getPointer());
    if (p) {
      const tpbind_dbl_t::traittype &t =
          *reinterpret_cast<const tpbind_dbl_t::traittype *>(&desc->traits.d);
      printf("p(%p)->set_param_default: typeid:%s desc:%p (%p)\n", p,
             typeid(tpbind_dbl_t::traittype).name(), desc, &desc->traits.d);
      p->setDefaultValue(t.def);
    }
    return true;
  }
};

/* primitive: TNotAnimatableParam */
template <typename Bind>
struct set_param_default_t<Bind, std::false_type> {
  static bool set_param_default(Param *param, const toonz_param_desc_t *desc) {
    auto smartptr = param->param();
    typename Bind::realtype *p =
        reinterpret_cast<typename Bind::realtype *>(smartptr.getPointer());
    if (p) {
      const typename Bind::traittype &t =
          *reinterpret_cast<const typename Bind::traittype *>(&desc->traits.d);
      printf("p(%p)->set_param_default: typeid:%s desc:%p (%p)\n", p,
             typeid(typename Bind::traittype).name(), desc, &desc->traits.d);
      p->setDefaultValue(t.def);
      p->setValue(t.def, false);
    }
    return true;
  }
};

/* Default Enum */
template <>
struct set_param_default_t<tpbind_enm_t, std::false_type> {
  static bool set_param_default(Param *param, const toonz_param_desc_t *desc) {
    auto smartptr = param->param();
    tpbind_enm_t::realtype *p =
        reinterpret_cast<tpbind_enm_t::realtype *>(smartptr.getPointer());
    if (p) {
      const tpbind_enm_t::traittype &t =
          *reinterpret_cast<const tpbind_enm_t::traittype *>(&desc->traits.d);
      for (int i = 0; i < t.enums; i++) {
        p->addItem(i, t.array[i]);
      }
      p->setValue(t.def, false);
    }
    return true;
  }
};

template <typename Bind>
bool set_param_default(Param *param, const toonz_param_desc_t *desc) {
  if (!is_type_of<typename Bind::traittype>(desc)) return false;
  return set_param_default_t<Bind>::set_param_default(param, desc);
}

template <typename T>
inline T *param_factory_(const toonz_param_desc_t *desc) {
  return new T;
}

template <>
inline TPointParam *param_factory_(const toonz_param_desc_t *desc) {
  return new TPointParam(TPointD(), true /* instanciate from plugin */);
}

template <>
inline TSpectrumParam *param_factory_(const toonz_param_desc_t *desc) {
  const toonz_param_traits_spectrum_t &t = desc->traits.g;
  if (t.points) {
    std::vector<TSpectrum::ColorKey> keys(t.points);
    for (int i = 0; i < t.points; i++) {
      keys[i].first  = t.array[i].w;
      keys[i].second = toPixel32(
          TPixelD(t.array[i].c0, t.array[i].c1, t.array[i].c2, t.array[i].m));
    }
    return new TSpectrumParam(t.points, keys.data());
  } else {
    return new TSpectrumParam(); /* use default constructor: デフォルトでは
                                    [black:white] の単純なものが設定される */
  }
}

inline TParam *parameter_factory(const toonz_param_desc_t *desc) {
  switch (desc->traits_tag) {
  case TOONZ_PARAM_TYPE_DOUBLE:
    return param_factory_<TDoubleParam>(desc);
  case TOONZ_PARAM_TYPE_RANGE:
    return param_factory_<TRangeParam>(desc);
  case TOONZ_PARAM_TYPE_PIXEL:
    return param_factory_<TPixelParam>(desc);
  case TOONZ_PARAM_TYPE_POINT:
    return param_factory_<TPointParam>(desc);
  case TOONZ_PARAM_TYPE_ENUM:
    return param_factory_<TIntEnumParam>(desc);
  case TOONZ_PARAM_TYPE_INT:
    return param_factory_<TIntParam>(desc);
  case TOONZ_PARAM_TYPE_BOOL:
    return param_factory_<TBoolParam>(desc);
  case TOONZ_PARAM_TYPE_SPECTRUM:
    return param_factory_<TSpectrumParam>(desc);
  case TOONZ_PARAM_TYPE_STRING:
    return param_factory_<TStringParam>(desc);
  case TOONZ_PARAM_TYPE_TONECURVE:
    return param_factory_<TToneCurveParam>(desc);
  default:
    break;
  }
  return NULL;
}

template <typename T>
inline int check_pollution_(const T &t) {
  if (t.reserved_) return TOONZ_PARAM_ERROR_POLLUTED;
  return 0;
}

template <typename T>
inline int check_traits_sanity_(const toonz_param_desc_t *desc) {
  const T &t = reinterpret_cast<const T &>(desc->traits.d);
  return check_pollution_<T>(t);
}

template <>
inline int check_traits_sanity_<toonz_param_traits_double_t>(
    const toonz_param_desc_t *desc) {
  int err                              = 0;
  const toonz_param_traits_double_t &t = desc->traits.d;
  err |= check_pollution_(t);
  if (t.min > t.max) err |= TOONZ_PARAM_ERROR_MIN_MAX;
  return 0;
}

template <>
inline int check_traits_sanity_<toonz_param_traits_range_t>(
    const toonz_param_desc_t *desc) {
  int err                             = 0;
  const toonz_param_traits_range_t &t = desc->traits.rd;
  err |= check_pollution_(t);
  if (t.minmax.a == 0 && t.minmax.b == 0)
    return err; /* range に興味がない場合の 0,0 を許す */
  if (t.minmax.a > t.minmax.b) err |= TOONZ_PARAM_ERROR_MIN_MAX;
  return err;
}

template <>
inline int check_traits_sanity_<toonz_param_traits_enum_t>(
    const toonz_param_desc_t *desc) {
  int err                            = 0;
  const toonz_param_traits_enum_t &t = desc->traits.e;
  err |= check_pollution_(t);
  if (t.enums == 0) return err;
  if (t.enums < 0) err |= TOONZ_PARAM_ERROR_ARRAY_NUM;
  if (t.array == NULL) err |= TOONZ_PARAM_ERROR_ARRAY;
  return err;
}

template <>
inline int check_traits_sanity_<toonz_param_traits_spectrum_t>(
    const toonz_param_desc_t *desc) {
  int err                                = 0;
  const toonz_param_traits_spectrum_t &t = desc->traits.g;
  err |= check_pollution_(t);
  if (t.points == 0) return err;
  if (t.points < 0) err |= TOONZ_PARAM_ERROR_ARRAY_NUM;
  if (t.array == NULL) err |= TOONZ_PARAM_ERROR_ARRAY;
  return err;
}

/*
template <> int check_traits_sanity_< toonz_param_traits_tonecurve_t >(const
toonz_param_desc_t* desc)
{
        int err = 0;
        const toonz_param_traits_tonecurve_t& t = desc->traits.tcv;
        err |= check_pollution_(t);
        if (t.points == 0)
                return err;
        if (t.points < 0)
                err |= TOONZ_PARAM_ERROR_ARRAY_NUM;
        if (t.array == NULL)
                err |= TOONZ_PARAM_ERROR_ARRAY;
        return err;
}
*/

inline int check_traits_sanity(const toonz_param_desc_t *desc) {
  int err = 0;
  switch (desc->traits_tag) {
  case TOONZ_PARAM_TYPE_DOUBLE:
    err = check_traits_sanity_<toonz_param_traits_double_t>(desc);
    break;
  case TOONZ_PARAM_TYPE_RANGE:
    err = check_traits_sanity_<toonz_param_traits_range_t>(desc);
    break;
  case TOONZ_PARAM_TYPE_PIXEL:
    err = check_traits_sanity_<toonz_param_traits_color_t>(desc);
    break;
  case TOONZ_PARAM_TYPE_POINT:
    err = check_traits_sanity_<toonz_param_traits_point_t>(desc);
    break;
  case TOONZ_PARAM_TYPE_ENUM:
    err = check_traits_sanity_<toonz_param_traits_enum_t>(desc);
    break;
  case TOONZ_PARAM_TYPE_INT:
    err = check_traits_sanity_<toonz_param_traits_int_t>(desc);
    break;
  case TOONZ_PARAM_TYPE_BOOL:
    err = check_traits_sanity_<toonz_param_traits_bool_t>(desc);
    break;
  case TOONZ_PARAM_TYPE_SPECTRUM:
    err = check_traits_sanity_<toonz_param_traits_spectrum_t>(desc);
    break;
  case TOONZ_PARAM_TYPE_STRING:
    err = check_traits_sanity_<toonz_param_traits_string_t>(desc);
    break;
  case TOONZ_PARAM_TYPE_TONECURVE:
    err = check_traits_sanity_<toonz_param_traits_tonecurve_t>(desc);
    break;
  default:
    err = TOONZ_PARAM_ERROR_TRAITS;
    break;
  }
  return err;
}

template <typename T>
inline bool param_type_check_(TParam *p, const toonz_param_desc_t *desc,
                              size_t &vsz) {
  if (typename T::realtype *d = dynamic_cast<typename T::realtype *>(p)) {
    if (is_type_of<typename T::traittype>(desc)) {
      vsz = sizeof(typename T::traittype::iovaluetype);
      return true;
    }
  }
  return false;
}

inline bool parameter_type_check(TParam *p, const toonz_param_desc_t *desc,
                                 size_t &vsz) {
  switch (desc->traits_tag) {
  case TOONZ_PARAM_TYPE_DOUBLE:
    return param_type_check_<tpbind_dbl_t>(p, desc, vsz);
  case TOONZ_PARAM_TYPE_RANGE:
    return param_type_check_<tpbind_rng_t>(p, desc, vsz);
  case TOONZ_PARAM_TYPE_PIXEL:
    return param_type_check_<tpbind_col_t>(p, desc, vsz);
  case TOONZ_PARAM_TYPE_POINT:
    return param_type_check_<tpbind_pnt_t>(p, desc, vsz);
  case TOONZ_PARAM_TYPE_ENUM:
    return param_type_check_<tpbind_enm_t>(p, desc, vsz);
  case TOONZ_PARAM_TYPE_INT:
    return param_type_check_<tpbind_int_t>(p, desc, vsz);
  case TOONZ_PARAM_TYPE_BOOL:
    return param_type_check_<tpbind_bool_t>(p, desc, vsz);
  case TOONZ_PARAM_TYPE_SPECTRUM:
    return param_type_check_<tpbind_spc_t>(p, desc, vsz);
  case TOONZ_PARAM_TYPE_STRING:
    return param_type_check_<tpbind_str_t>(p, desc, vsz);
  case TOONZ_PARAM_TYPE_TONECURVE:
    return param_type_check_<tpbind_tcv_t>(p, desc, vsz);
  default:
    break;
  }
  return false;
}

template <typename T>
inline bool param_read_value_(TParam *p, const toonz_param_desc_t *desc,
                              void *ptr, double frame, size_t isize,
                              size_t &osize) {
  /* isize は iovaluetype の size でなく count になったのでサイズチェックは無効
   */
  // if (isize == sizeof(typename T::traittype::iovaluetype)) {
  auto r = reinterpret_cast<typename T::realtype *>(p);
  auto v = r->getValue();
  *reinterpret_cast<typename T::traittype::iovaluetype *>(ptr) = v;
  osize                                                        = 1;
  return true;
  //}
  return false;
}

template <>
inline bool param_read_value_<tpbind_dbl_t>(TParam *p,
                                            const toonz_param_desc_t *desc,
                                            void *ptr, double frame,
                                            size_t isize, size_t &osize) {
  // if (isize == sizeof(tpbind_dbl_t::traittype::iovaluetype)) {
  auto r = reinterpret_cast<tpbind_dbl_t::realtype *>(p);
  auto v = r->getValue(frame);
  *reinterpret_cast<tpbind_dbl_t::traittype::iovaluetype *>(ptr) = v;
  osize                                                          = 1;
  return true;
  //}
  return false;
}

template <>
inline bool param_read_value_<tpbind_str_t>(TParam *p,
                                            const toonz_param_desc_t *desc,
                                            void *ptr, double frame,
                                            size_t isize, size_t &osize) {
  auto r                = reinterpret_cast<tpbind_str_t::realtype *>(p);
  const std::string str = QString::fromStdWString(r->getValue()).toStdString();
  std::size_t len       = str.length() + 1;
  /* get_type() の返す大きさも文字列長+1 を含んでいる */
  if (isize < len)
    len = isize; /* 要求サイズが実際の長さより短くても良いが切り詰める(ただし 1
                    以上であること) */

  if (len > 0) {
    auto dst = reinterpret_cast<char *>(ptr);
    strncpy(dst, str.c_str(), len - 1);
    dst[len - 1] = '\0';
    osize        = len;
    return true;
  }
  return false;
}

template <>
inline bool param_read_value_<tpbind_rng_t>(TParam *p,
                                            const toonz_param_desc_t *desc,
                                            void *ptr, double frame,
                                            size_t isize, size_t &osize) {
  // if (isize == sizeof(tpbind_rng_t::traittype::iovaluetype)) {
  auto r   = reinterpret_cast<tpbind_rng_t::realtype *>(p);
  auto v   = r->getValue(frame);
  auto dst = reinterpret_cast<tpbind_rng_t::traittype::iovaluetype *>(ptr);
  dst->a   = v.first;
  dst->b   = v.second;
  osize    = 1;
  return true;
  //}
  return false;
}

template <>
inline bool param_read_value_<tpbind_col_t>(TParam *p,
                                            const toonz_param_desc_t *desc,
                                            void *ptr, double frame,
                                            size_t isize, size_t &osize) {
  // if (isize == sizeof(tpbind_col_t::traittype::iovaluetype)) {
  auto r = reinterpret_cast<tpbind_col_t::realtype *>(p);
  /* getValueD() だと 16bit * 4 が返る */
  // auto v = r->getValueD(frame);
  auto v   = r->getValue(frame);
  auto dst = reinterpret_cast<tpbind_col_t::traittype::iovaluetype *>(ptr);
  dst->c0  = v.r;
  dst->c1  = v.g;
  dst->c2  = v.b;
  dst->m   = v.m;
  osize    = 1;
  return true;
  //}
  return false;
}

template <>
inline bool param_read_value_<tpbind_pnt_t>(TParam *p,
                                            const toonz_param_desc_t *desc,
                                            void *ptr, double frame,
                                            size_t isize, size_t &osize) {
  // if (isize == sizeof(tpbind_pnt_t::traittype::iovaluetype)) {
  auto r   = reinterpret_cast<tpbind_pnt_t::realtype *>(p);
  auto v   = r->getValue(frame);
  auto dst = reinterpret_cast<tpbind_pnt_t::traittype::iovaluetype *>(ptr);
  dst->x   = v.x;
  dst->y   = v.y;
  osize    = 1;
  return true;
  //}
  return false;
}

template <>
inline bool param_read_value_<tpbind_spc_t>(TParam *p,
                                            const toonz_param_desc_t *desc,
                                            void *ptr, double frame,
                                            size_t isize, size_t &osize) {
  // if (isize == sizeof(tpbind_spc_t::traittype::iovaluetype)) {
  auto r   = reinterpret_cast<tpbind_spc_t::realtype *>(p);
  auto dst = reinterpret_cast<tpbind_spc_t::traittype::iovaluetype *>(ptr);
  /* getValue64() だと 1channle 16bit が返るがデフォルト型に合わせる */
  auto v  = r->getValue(frame).getValue(dst->w);
  dst->c0 = v.r;
  dst->c1 = v.g;
  dst->c2 = v.b;
  dst->m  = v.m;
  osize   = 1;
  return true;
  //}
  return false;
}

template <>
inline bool param_read_value_<tpbind_tcv_t>(TParam *p,
                                            const toonz_param_desc_t *desc,
                                            void *ptr, double frame,
                                            size_t isize, size_t &osize) {
  auto r                = reinterpret_cast<tpbind_tcv_t::realtype *>(p);
  QList<TPointD> points = r->getValue(frame);
  size_t ps             = points.size();
  /* コントロールポイントのリストしか戻って来ない！ */
  if (isize >= ps) {
    int channel = r->getCurrentChannel();
    int interp  = !r->isLinear();
    int c       = isize < points.size() ? isize : points.size();
    for (int i = 0; i < c; i++) {
      auto dst = reinterpret_cast<tpbind_tcv_t::traittype::iovaluetype *>(ptr);
      dst[i].x = points[i].x;
      dst[i].y = points[i].y;
      dst[i].channel = channel;
      dst[i].interp  = interp;
    }
    osize = c;
    return true;
  }
  return false;
}

inline bool parameter_read_value(TParam *p, const toonz_param_desc_t *desc,
                                 void *ptr, double frame, size_t isize,
                                 size_t &osize) {
  size_t sz = 0;
  if (!parameter_type_check(p, desc, sz)) {  // typecheck
    return false;
  }

  switch (desc->traits_tag) {
  case TOONZ_PARAM_TYPE_DOUBLE:
    return param_read_value_<tpbind_dbl_t>(p, desc, ptr, frame, isize, osize);
  case TOONZ_PARAM_TYPE_RANGE:
    return param_read_value_<tpbind_rng_t>(p, desc, ptr, frame, isize, osize);
  case TOONZ_PARAM_TYPE_PIXEL:
    return param_read_value_<tpbind_col_t>(p, desc, ptr, frame, isize, osize);
  case TOONZ_PARAM_TYPE_POINT:
    return param_read_value_<tpbind_pnt_t>(p, desc, ptr, frame, isize, osize);
  case TOONZ_PARAM_TYPE_ENUM:
    return param_read_value_<tpbind_enm_t>(p, desc, ptr, frame, isize, osize);
  case TOONZ_PARAM_TYPE_INT:
    return param_read_value_<tpbind_int_t>(p, desc, ptr, frame, isize, osize);
  case TOONZ_PARAM_TYPE_BOOL:
    return param_read_value_<tpbind_bool_t>(p, desc, ptr, frame, isize, osize);
  case TOONZ_PARAM_TYPE_SPECTRUM:
    return param_read_value_<tpbind_spc_t>(p, desc, ptr, frame, isize, osize);
  case TOONZ_PARAM_TYPE_STRING:
    return param_read_value_<tpbind_str_t>(p, desc, ptr, frame, isize, osize);
  case TOONZ_PARAM_TYPE_TONECURVE:
    return param_read_value_<tpbind_tcv_t>(p, desc, ptr, frame, isize, osize);
  default:
    break;
  }
  return false;
}

#endif