#pragma once

#include <string>
#include <vector>
#include <memory>

namespace Incart::Net::WebApi
{

enum class EJsonCommandUnitType
{
  Int,
  Float,
  Bool,
  String,
  Binary,
  Object,
  Array
};

struct JsonCommandUnit
{
  std::string name;
  EJsonCommandUnitType type;

  JsonCommandUnit(const std::string& name_, EJsonCommandUnitType type_) :
    name(name_)
    , type(type_)
  {
  }

  virtual ~JsonCommandUnit(){}

  virtual std::string toString(size_t spaceCount, bool /*canSetQuotes*/) const
  {
    return createSpaces(spaceCount) + "\"" + name + "\": \"" + unitTypeToString(type) + "\"";
  }

  static std::string createSpaces(size_t spaceCount)
  {
    std::string spaces = "";
    spaces.insert(spaces.begin(), spaceCount, ' ');
    return spaces;
  }

  static std::string unitTypeToString(EJsonCommandUnitType type)
  {
    switch (type)
    {
    case EJsonCommandUnitType::Int:
      return "int";
    case EJsonCommandUnitType::Float:
      return "float";
    case EJsonCommandUnitType::Bool:
      return "bool";
    case EJsonCommandUnitType::String:
      return "string";
    case EJsonCommandUnitType::Binary:
      return "binary";
    case EJsonCommandUnitType::Object:
      return "object";
    case EJsonCommandUnitType::Array:
      return "array";
    default:
      return "unknown";
    }
  }
};

struct NamelessJsonCommandUnit
{
  EJsonCommandUnitType type;

  NamelessJsonCommandUnit(EJsonCommandUnitType type_) : type(type_)
  {
  }

  virtual ~NamelessJsonCommandUnit()
  {
  }

  virtual std::string toString(size_t/* spaceCount*/, bool canSetQuotes) const
  {
    std::string text = "";
    if (canSetQuotes)
    {
      text += "\"";
    }
    text += JsonCommandUnit::unitTypeToString(type);
    if (canSetQuotes)
    {
      text += "\"";
    }
    return text;
  }
};

struct NamelessJsonCommandObjectUnit : public NamelessJsonCommandUnit
{
  std::vector<std::shared_ptr<JsonCommandUnit>> fields;

  NamelessJsonCommandObjectUnit(const std::vector<std::shared_ptr<JsonCommandUnit>>& fields_) : NamelessJsonCommandUnit(EJsonCommandUnitType::Object)
    , fields(fields_)
  {
  }

  std::string toString(size_t spaceCount, bool /*canSetQuotes*/) const override
  {
    std::string text = "{\r\n";
    for (size_t i = 0; i < fields.size(); ++i)
    {
      text += fields[i]->toString(spaceCount + 2, true);
      if (i < (fields.size() - 1))
      {
        text += ",";
      }
      text += "\r\n";
    }
    text += "}";
    return text;
  }
};

struct NamelessEmptyJsonCommandUnit : public NamelessJsonCommandObjectUnit
{
  NamelessEmptyJsonCommandUnit() : NamelessJsonCommandObjectUnit({})
  {
  }
};

struct NamelessJsonCommandArrayUnit : public NamelessJsonCommandUnit
{
  size_t count; // 0 - unlimited
  std::shared_ptr<NamelessJsonCommandUnit> item;

  NamelessJsonCommandArrayUnit(size_t count_, std::shared_ptr<NamelessJsonCommandUnit> item_) : NamelessJsonCommandUnit(EJsonCommandUnitType::Array)
    , count(count_)
    , item(item_)
  {
  }

  std::string toString(size_t spaceCount, bool canSetQuotes) const override
  {
    std::string text = "";
    if (canSetQuotes)
    {
      text += "\"";
    }
    text += "array";
    if (count > 0)
    {
      text += "(" + std::to_string(count) + ")";
    }
    text += " of " + item->toString(spaceCount + 2, false);
    if (canSetQuotes)
    {
      text += "\"";
    }
    return text;
  }
};

struct JsonCommandArrayUnit : public JsonCommandUnit
{
  const size_t UnlimitedSize = 0;

  size_t count; // 0 - unlimited
  std::shared_ptr<NamelessJsonCommandUnit> item;

  JsonCommandArrayUnit(const std::string& name_, size_t count_, std::shared_ptr<NamelessJsonCommandUnit> item_) : JsonCommandUnit(name_, EJsonCommandUnitType::Array)
    , count(count_)
    , item(item_)
  {
  }

  std::string toString(size_t spaceCount, bool /*canSetQuotes*/) const override
  {
    std::string text = createSpaces(spaceCount) + "\"" + name + "\": \"array";
    if (count > 0)
    {
      text += "(" + std::to_string(count) + ")";
    }
    text += "\",\r\n" + createSpaces(spaceCount + 2) + "\"__" + name + "_items\": " + item->toString(spaceCount + 2, true);
    return text;
  }
};

struct JsonCommandObjectUnit : public JsonCommandUnit
{
  std::vector<std::shared_ptr<JsonCommandUnit>> fields;

  JsonCommandObjectUnit(const std::string& name_, const std::vector<std::shared_ptr<JsonCommandUnit>>& fields_) : JsonCommandUnit(name_, EJsonCommandUnitType::Object)
    , fields(fields_)
  {
  }

  std::string toString(size_t spaceCount, bool /*canSetQuotes*/) const override
  {
    std::string text = createSpaces(spaceCount) + "\"" + name + "\": {\r\n";
    for (size_t i = 0; i < fields.size(); ++i)
    {
      text += fields[i]->toString(spaceCount + 2, true);
      if (i < (fields.size() - 1))
      {
        text += ",";
      }
      text += "\r\n";
    }
    text += "}";
    return text;
  }
};

struct EmptyJsonCommandUnit : public JsonCommandObjectUnit
{
  EmptyJsonCommandUnit(const std::string& name_) : JsonCommandObjectUnit(name_, {})
  {
  }
};

struct JsonCommandDescription : public JsonCommandUnit
{
    std::shared_ptr<NamelessJsonCommandUnit> data;
    std::shared_ptr<NamelessJsonCommandUnit> answer;

    JsonCommandDescription(const std::string& name_, std::shared_ptr<NamelessJsonCommandUnit> data_,
      std::shared_ptr<NamelessJsonCommandUnit> answer_) : JsonCommandUnit(name_, EJsonCommandUnitType::Object)
      , data(data_)
      , answer(answer_)
    {
    }

    std::string toString(size_t spaceCount, bool /*canSetQuotes*/) const override
    {
      std::string text = createSpaces(spaceCount) + "{\r\n";
      text += createSpaces(spaceCount + 2) + "\"cmd\": \"" + name + "\",\r\n";
      text += createSpaces(spaceCount + 2) + "\"data\": " + data->toString(0, true) + ",\r\n";
      text += createSpaces(spaceCount + 2) + "\"answer\": " + answer->toString(0, true) + "\r\n}";
      return text;
    }
};

} // namespace Incart::Net::WebApi