#include "tnotanimatableparam.h"

#include "tstream.h"

PERSIST_IDENTIFIER(TIntParam, "intParam")

PERSIST_IDENTIFIER(TBoolParam, "boolParam")

PERSIST_IDENTIFIER(TFilePathParam, "filePathParam")

PERSIST_IDENTIFIER(TStringParam, "stringParam")

PERSIST_IDENTIFIER(TNADoubleParam, "naDoubleParam")

// PERSIST_IDENTIFIER(TIntEnumParam, "intEnumParam")

TPersistDeclarationT<tenumparam> TEnumParam::m_declaration("intEnumParam");</tenumparam>

//=========================================================

void TIntParam::loadData(TIStream &is) {

  int def, value;

  is >> def;

  if (is.eos()) {

    def += 1;

    setDefaultValue(def);

    setValue(def, false);

    return;

  }

  setDefaultValue(def);

  is >> value;

  setValue(value, false);

}

//---------------------------------------------------------

void TIntParam::saveData(TOStream &os) {

  os << getDefaultValue();

  os << getValue();

}

//---------------------------------------------------------

bool TIntParam::isWheelEnabled() const { return m_isWheelEnabled; }

//---------------------------------------------------------

void TIntParam::enableWheel(bool on) { m_isWheelEnabled = on; }

//=========================================================

void TBoolParam::loadData(TIStream &is) {

  int def, value;

  is >> def >> value;

  setDefaultValue(def ? true : false);

  setValue(value ? true : false, false);

}

//---------------------------------------------------------

void TBoolParam::saveData(TOStream &os) {

  os << (int)getDefaultValue() << (int)getValue();

}

//=========================================================

void TFilePathParam::loadData(TIStream &is) {

  TFilePath def, value;

  is >> def >> value;

  setDefaultValue(def);

  setValue(value, false);

}

//---------------------------------------------------------

void TFilePathParam::saveData(TOStream &os) {

  os << getDefaultValue();

  os << getValue();

}

//=========================================================

void TStringParam::loadData(TIStream &is) {

  std::wstring def, value;

  is >> def >> value;

  setDefaultValue(def);

  setValue(value, false);

}

void TStringParam::saveData(TOStream &os) {

  os << getDefaultValue();

  os << getValue();

}

//=========================================================

void TNADoubleParam::loadData(TIStream &is) {

  double def, value;

  is >> def >> value;

  setDefaultValue(def);

  setValue(value, false);

}

void TNADoubleParam::saveData(TOStream &os) {

  os << getDefaultValue();

  os << getValue();

}

//=========================================================

//=========================================================

namespace {

template <typename t=""></typename>

class matchesValue {

  T m_v;

public:

  matchesValue(T v) : m_v(v) {}

  bool operator()(const std::pair<t, std::string=""> &p) { return m_v == p.first; }</t,>

};

}

//---------------------------------------------------------

class TEnumParamImp {

public:

  std::vector<std::pair<int, std::string="">> m_items;</std::pair<int,>

  void copy(std::unique_ptr<tenumparamimp> &src) {</tenumparamimp>

    m_items.clear();

    std::back_insert_iterator<std::vector<std::pair<int, std::string="">>> bii(</std::vector<std::pair<int,>

        m_items);

    std::copy(src->m_items.begin(), src->m_items.end(), bii);

  }

  bool checkValue(int v) {

    std::vector<std::pair<int, std::string="">>::iterator it =</std::pair<int,>

        std::find_if(m_items.begin(), m_items.end(), matchesValue<int>(v));</int>

    return it != m_items.end();

  }

};

//---------------------------------------------------------

TEnumParam::TEnumParam(const int &v, const std::string &caption)

    : TNotAnimatableParam<int>(v), m_imp(new TEnumParamImp()) {</int>

  addItem(v, caption);

}

//---------------------------------------------------------

void TEnumParam::copy(TParam *src) {

  TNotAnimatableParam<int>::copy(src);</int>

  TEnumParam *p = dynamic_cast<tenumparam *="">(src);</tenumparam>

  if (!p) throw TException("invalid source for copy");

  TEnumParam::setName(src->getName());

  m_imp->copy(p->m_imp);

}

//---------------------------------------------------------

TEnumParam::~TEnumParam() {}

//---------------------------------------------------------

TEnumParam::TEnumParam(const TEnumParam &src)

    : TNotAnimatableParam<int>(src), m_imp(new TEnumParamImp(*src.m_imp)) {}</int>

//---------------------------------------------------------

TEnumParam::TEnumParam()

    : TNotAnimatableParam<int>()</int>

    , m_imp(new TEnumParamImp())

{}

//---------------------------------------------------------

void TEnumParam::setValue(int v, bool undoing) {

  bool valid = false;

  std::vector<std::pair<int, std::string="">>::iterator it =</std::pair<int,>

      m_imp->m_items.begin();

  for (; it != m_imp->m_items.end(); ++it) {

    if (it->first == v) {

      valid = true;

      break;

    }

  }

  if (!valid) throw TException("out of range parameter value");

  TNotAnimatableParam<int>::setValue(v, undoing);</int>

}

//---------------------------------------------------------

void TEnumParam::setValue(const std::string &caption, bool undoing) {

  bool valid = false;

  int v      = 0;

  std::vector<std::pair<int, std::string="">>::iterator it =</std::pair<int,>

      m_imp->m_items.begin();

  for (; it != m_imp->m_items.end(); ++it) {

    if (it->second == caption) {

      v     = it->first;

      valid = true;

      break;

    }

  }

  if (!valid) throw TException("out of range parameter value");

  TNotAnimatableParam<int>::setValue(v, undoing);</int>

}

//---------------------------------------------------------

void TEnumParam::addItem(const int &item, const std::string &caption) {

  m_imp->m_items.push_back(std::make_pair(item, caption));

}

//---------------------------------------------------------

int TEnumParam::getItemCount() const { return m_imp->m_items.size(); }

//---------------------------------------------------------

void TEnumParam::getItem(int i, int &item, std::string &caption) const {

  assert(i >= 0 && i < m_imp->m_items.size());

  item    = m_imp->m_items[i].first;

  caption = m_imp->m_items[i].second;

}

//---------------------------------------------------------

void TEnumParam::loadData(TIStream &is) {

  int value;

  is >> value;

  try {

    setValue(value, false);

  } catch (TException &) {

    TNotAnimatableParam<int>::reset();</int>

  }

}

//---------------------------------------------------------

void TEnumParam::saveData(TOStream &os) {

  os << TNotAnimatableParam<int>::getValue();</int>

}

//---------------------------------------------------------

void TIntParam::setValueRange(int min, int max) {

  assert(min < max);

  minValue = min;

  maxValue = max;

}

bool TIntParam::getValueRange(int &min, int &max) const {

  min = minValue;

  max = maxValue;

  return min < max;

}