#include "map_value.h"
#include <sstream>
#include <iostream>

MapValue::MapValue()
{
  //std::cout << __PRETTY_FUNCTION__ << std::endl;
  has_value = false;
}

MapValue::MapValue(double d)
{
  //std::cout << __PRETTY_FUNCTION__ << std::endl;
  p_value = new double(d);
  type = NUMERIC;
  has_value = true;
}

MapValue::MapValue(std::string str)
{
  //std::cout << __PRETTY_FUNCTION__ << std::endl;
  p_value = new std::string(str);
  type = STRING;
  has_value = true;
}

MapValue::MapValue(const char* str)
{
  //std::cout << __PRETTY_FUNCTION__ << std::endl;
  p_value = new std::string(str);
  type = STRING;
  has_value = true;
}

MapValue::operator double() const
{
  //std::cout << __PRETTY_FUNCTION__ << std::endl;
  if (!has_value) throw IllegalOperation();
  if (type == NUMERIC)
    return *(static_cast<double*>(p_value));
  else
    throw IllegalOperation();
}

MapValue::operator std::string() const
{
  //std::cout << __PRETTY_FUNCTION__ << std::endl;
  if (!has_value) throw IllegalOperation();
  std::string ret;
  switch (type)
  {
    case NUMERIC:
      {
        double d = *(static_cast<double*>(p_value));
        std::ostringstream ostr;
        ostr << d;
        ret = ostr.str();
      }
      break;
    case STRING:
      ret = *(static_cast<std::string*>(p_value));
      break;
  }
  return ret;
}

MapValue::MapValue(const MapValue& v)
{
  //std::cout << __PRETTY_FUNCTION__ << std::endl;
  if (!v.has_value) throw IllegalOperation();
  has_value = true;
  type = v.type;
  switch (v.type)
  {
    case NUMERIC:
      p_value = new double(*(static_cast<double*>(v.p_value)));
      break;
    case STRING:
      p_value = new std::string(*(static_cast<std::string*>(v.p_value)));
      break;
  }
}

MapValue& MapValue::operator=(const MapValue& v)
{
  //std::cout << __PRETTY_FUNCTION__ << std::endl;
  if (&v != this)
  {
    if (!v.has_value) throw IllegalOperation();
    clear();
    has_value = true;
    type = v.type;
    switch (v.type)
    {
      case NUMERIC:
        p_value = new double(*(static_cast<double*>(v.p_value)));
        break;
      case STRING:
        p_value = new std::string(*(static_cast<std::string*>(v.p_value)));
        break;
    }
  }
  return *this;
}

MapValue::~MapValue()
{
  //std::cout << __PRETTY_FUNCTION__ << std::endl;
  clear();
}

void MapValue::clear()
{
  //std::cout << __PRETTY_FUNCTION__ << std::endl;
  if (!has_value) return;
  switch (type)
  {
    case NUMERIC:
      delete static_cast<double*>(p_value);
      break;
    case STRING:
      delete static_cast<std::string*>(p_value);
      break;
  }
}

MapValue::Type MapValue::getType() const
{
  //std::cout << __PRETTY_FUNCTION__ << std::endl;
  return type;
}

bool MapValue::hasValue() const
{
  //std::cout << __PRETTY_FUNCTION__ << std::endl;
  return has_value;
}

std::ostream& operator<<(std::ostream &os, const MapValue& v)
{
  //std::cout << __PRETTY_FUNCTION__ << std::endl;
  if (!v.has_value) return os;
  switch (v.type)
  {
    case MapValue::NUMERIC:
      os << *(static_cast<double*>(v.p_value));
      break;
    case MapValue::STRING:
      os << *(static_cast<std::string*>(v.p_value));
      break;
  }
  return os;
}