#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");
 
//=========================================================
 
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>
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; }
};
}
 
//---------------------------------------------------------
 
class TEnumParamImp {
public:
  std::vector<std::pair<int, std::string>> m_items;
  void copy(std::unique_ptr<TEnumParamImp> &src) {
    m_items.clear();
    std::back_insert_iterator<std::vector<std::pair<int, std::string>>> bii(
        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::find_if(m_items.begin(), m_items.end(), matchesValue<int>(v));
    return it != m_items.end();
  }
};
 
//---------------------------------------------------------
 
TEnumParam::TEnumParam(const int &v, const std::string &caption)
    : TNotAnimatableParam<int>(v), m_imp(new TEnumParamImp()) {
  addItem(v, caption);
}
 
//---------------------------------------------------------
 
void TEnumParam::copy(TParam *src) {
  TNotAnimatableParam<int>::copy(src);
  TEnumParam *p = dynamic_cast<TEnumParam *>(src);
  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)) {}
 
//---------------------------------------------------------
 
TEnumParam::TEnumParam()
    : TNotAnimatableParam<int>()
    , m_imp(new TEnumParamImp())
 
{}
 
//---------------------------------------------------------
 
void TEnumParam::setValue(int v, bool undoing) {
  bool valid = false;
  std::vector<std::pair<int, std::string>>::iterator it =
      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);
}
 
//---------------------------------------------------------
 
void TEnumParam::setValue(const std::string &caption, bool undoing) {
  bool valid = false;
  int v      = 0;
  std::vector<std::pair<int, std::string>>::iterator it =
      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);
}
 
//---------------------------------------------------------
 
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();
  }
}
 
//---------------------------------------------------------
 
void TEnumParam::saveData(TOStream &os) {
  os << TNotAnimatableParam<int>::getValue();
}
 
//---------------------------------------------------------
 
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;
}