#include <type_traits>
#include <cstdint>
#include <cctype>
#include <vector>
#include <string>
#include <cstring>
#include <cstdlib>
#include <cassert>


template<typename T>
using Array     = std::vector<T>;
using String    = std::string;
using Integer32 = int32_t;


template <class V>
void Visit(V& v, Integer32& i)
{
  v.Visit(i);
}

template <class V>
void Visit(V& v, String& str)
{
  v.Visit(str);
}

template <class V, class T>
void Visit(V& v, Array<T>& arr)
{
  v.Visit(arr);
}

template <class V, class T>
void Visit(V& v, const char* /*name*/, T& var)
{
  //v.Enter(name);
  var.Visit(v);
  //v.Exit(name);
}


class XMLSerializerVisitor
{
public:
  XMLSerializerVisitor()
  {
    reset();
  }

  void Enter(const char* name)
  {
    indent(depth);
    output += "<";
    output += name;
    output += ">\n";
    depth++;
  }

  void Exit(const char* name)
  {
    depth--;
    indent(depth);
    output += "</";
    output += name;
    output += ">\n";
  }

  template <class T>
  void Visit(Array<T>& arr)
  {
/*
    Integer32 siz = arr.size();
    Visit("length", siz);
    for (int i = 0; i < arr.size(); i++)
    {
      char buf[1024];
      snprintf(buf, 1024, "element[%i]", i);
      Visit(buf, arr.at(i));
    }
*/
    for (auto i : arr)
    {
      Visit("item", i);
    }
  }

  void Visit(Integer32& var)
  {
    indent(depth);
    output += std::to_string(var);
    output += "\n";
  }

  void Visit(String& var)
  {
    // TODO: limitiation is that the string can not have a new line
    indent(depth);
    output += var;
    output += "\n";
  }

  template <class T>
  void Visit(const char* name, T& var)
  {
    Enter(name);
    ::Visit(*this, var);
    Exit(name);
  }

  std::string& Output()
  {
    output += "</xml>\n";
    return output;
  }
  void reset()
  {
    output = "<xml>\n";
    depth = 1;
  }
private:
  int depth = 0;
  std::string output;
  
  void indent(int spaces)
  {
    for(int i = 0; i < spaces; i++)
    {
      output += "  ";
    }
  }
};



class XMLDeserializerVisitor
{
public:
  XMLDeserializerVisitor(std::string data) : input(data)
  {
    String str;
    Visit(str);
    // deserialize the <xml> tag
  }

  void Enter(const char* name)
  {
    String str;
    Visit(str);
    //printf("enter deserializing for -%s-, got -%s-\n", name, str.c_str());
  }
  void Exit(const char* name)
  {
    String str;
    Visit(str);
    //printf("exit deserializing for -%s-, got -%s-\n", name, str.c_str());
  }

  template <class T>
  void Visit(Array<T>& arr)
  {
/*
    Integer32 siz = 0;
    Visit("length", siz);
    arr.resize(siz);
    //printf("deserializing array of len: %i\n", siz);
    for (int i = 0; i < arr.size(); i++)
    {
      char buf[1024];
      snprintf(buf, 1024, "element[%i]", i);
      Visit(buf, arr.at(i));
    }
*/
    while (true)
    {
      int oldOffset = offset;
      String str;
      Visit(str);
      offset = oldOffset;
      if (str != "<item>")
        break;

      T item;
      Visit("item", item);
      arr.push_back(item);
    }
  }

  void Visit(Integer32& var)
  {
    const char* ptr = input.c_str();
    char* endPtr;
    var = strtol(ptr + offset, &endPtr, 10);
    offset = endPtr - ptr;
  }

  void Visit(String& var)
  {
    stripWhiteSpace();
    int newLineOff = input.find("\n", offset);
    if (newLineOff != std::string::npos)
        var = input.substr(offset, newLineOff-offset);
    offset = newLineOff;
  }

  template <class T>
  void Visit(const char* name, T& var)
  {
    Enter(name);
    ::Visit(*this, var);
    Exit(name);
  }

private:
  std::string input;
  int offset = 0;
  void stripWhiteSpace()
  {
    while (isspace(input.c_str()[offset]))
    {
        offset++;
    }
  }
};


class JsonSerializerVisitor
{
public:
  JsonSerializerVisitor()
  {
    reset();
  }

  void Enter(const char* name)
  {
    output += indent(depth) + quoted(name) + " : {\n";
    depth++;
  }

  void Exit(const char* name)
  {
    output += "\n" + indent(--depth) + "}\n";
  }

  template <class T>
  void Visit(Array<T>& arr)
  {
    output += "[ ";
    for (int i = 0; i < arr.size(); i++)
    {
      Visit(arr.at(i));
      if ( i != arr.size() - 1 )
        output += " ,";
      output += " ";
    }
    output += "]";
  }

  void Visit(Integer32& var)
  {
    output += std::to_string(var);
  }

  void Visit(String& var)
  {
    output += quoted(var.c_str());
  }

  template <class T>
  void Visit(const char* name, T& var)
  {
    if (lastDepth == depth)
        output += " ,\n";
    lastDepth = depth;

    output += indent(depth) + quoted(name) + " : ";
    ::Visit(*this, var);
  }

  std::string& Output()
  {
    output += "}\n";
    return output;
  }
  void reset()
  {
    output = "{\n";
    depth = 1;
  }
private:
  int lastDepth = 0;
  int depth = 0;
  std::string output;
  
  std::string quoted(const char* name)
  {
    return std::string("\"" + std::string(name) + "\"");
  }
  std::string indent(int spaces)
  {
    return std::string(spaces*2, ' ');
  }
};



class JsonDeserializerVisitor
{
public:
  JsonDeserializerVisitor(std::string data) : input(data)
  {
    String str;
    ParseString(str); // gets the '{' 
    assert(str == "{");
  }

  void ParseString(String& var)
  {
    stripWhiteSpace();
    int pos = offset;
    while (input.c_str()[pos])
    {
        if (isspace(input.c_str()[pos]))
        {
            var = input.substr(offset, pos-offset);
            offset = pos;
            return;
        }
        pos++;
    }
  }

  void Enter(const char* name)
  {
    String str;
    ParseString(str); // gets the name
    //printf("name: -%s-", quoted(name).c_str());
    //printf("str:  -%s-", str.c_str());
    assert(str == quoted(name));
    ParseString(str); // gets the ':'
    assert(str == ":");
    ParseString(str); // gets the '{'
    assert(str == "{");
    //printf("enter deserializing for -%s-, got -%s-\n", name, str.c_str());
  }
  void Exit(const char* name)
  {
    String str;
    ParseString(str); // gets the '}'
    assert(str == "}");
    //printf("exit deserializing for -%s-, got -%s-\n", name, str.c_str());
  }

  template <class T>
  void Visit(Array<T>& arr)
  {
    String str;
    ParseString(str); // gets the '['
    assert(str == "[");
    while (true)
    {
      T item;
      Visit(item);
      arr.push_back(item);

      String str;
      ParseString(str); // gets the ',' or ']' or '],'
      if (str != ",")
      {
        //printf("expecting ]");
        //printf("str:  -%s-", str.c_str());
        assert(str == "]");
        break;
      }
    }
  }

  void Visit(Integer32& var)
  {
    const char* ptr = input.c_str();
    char* endPtr;
    var = strtol(ptr + offset, &endPtr, 10);
    offset = endPtr - ptr;
  }

  void Visit(String& var)
  {
    // TODO
    stripWhiteSpace();
    int newLineOff = input.find("\"", offset + 1);
    if (newLineOff != std::string::npos)
        var = input.substr(offset + 1, newLineOff - offset - 1);
    offset = newLineOff + 1;
  }

  template <class T>
  void Visit(const char* name, T& var)
  {
    String str;
    ParseString(str); // gets the name
    //printf("name: -%s-", quoted(name).c_str());
    //printf("str:  -%s-", str.c_str());
    assert(str == quoted(name));
    ParseString(str); // gets the ':'
    assert(str == ":");
    ::Visit(*this, var);

    int oldOffset = offset;
    ParseString(str); // gets the ',' if there
    if (str != ",")
        offset = oldOffset;
  }

private:
  std::string input;
  int offset = 0;
  std::string quoted(const char* name)
  {
    return std::string("\"" + std::string(name) + "\"");
  }
  void stripWhiteSpace()
  {
    while (isspace(input.c_str()[offset]))
    {
        offset++;
    }
  }
};



struct Person
{
  Integer32      id;
  String         name;
  Array<String>  email;
  Array<String>  phoneNumbers;

  // This can do both the serializing and de-serializing
  // This might be good to have generated, but possibly being more explicit could be better too
  // Also note the members could be private and this will still work
  template <class V>
  void Visit(V& v)
  {
    v.Enter("person");
    v.Visit("id",id);
    v.Visit("name",name);
    v.Visit("email",email);
    v.Visit("numbers",phoneNumbers);
    v.Exit("person");
  }
};





int main(int argc, char* argv[])
{
  std::string input;

  {  
    Person a;
    a.id = 10;
    a.name = "blah";
    a.email.push_back("em@ail.com");
    a.email.push_back("other@add.com");
    a.phoneNumbers.push_back("123555");

    XMLSerializerVisitor serializer;
    Visit(serializer, "personA", a);
    printf("%s", serializer.Output().c_str());
    input = serializer.Output();
  }

  {
    Person b;

    XMLDeserializerVisitor deserializer(input);
    Visit(deserializer, "personB", b);

    {
      XMLSerializerVisitor serializer;
      Visit(serializer, "personB", b);
      printf("%s", serializer.Output().c_str());
    }
  }


  {  
    Person a;
    a.id = 10;
    a.name = "blah";
    a.email.push_back("em@ail.com");
    a.email.push_back("other@add.com");
    a.phoneNumbers.push_back("123555");

    JsonSerializerVisitor serializer;
    Visit(serializer, "personA", a);
    printf("%s", serializer.Output().c_str());
    input = serializer.Output();
  }

  {
    Person b;

    JsonDeserializerVisitor deserializer(input);
    Visit(deserializer, "personB", b);

    {
      JsonSerializerVisitor serializer;
      Visit(serializer, "personB", b);
      printf("%s", serializer.Output().c_str());
    }
  }
}




