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


// Some basic types that should build serializable structures from
template<typename T>
using Array      = std::vector<T>;
using Boolean    = bool;
using Byte       = uint8_t;
using Char       = int8_t;
using Unsigned32 = uint32_t;
using Unsigned64 = uint64_t;
using Integer32  = int32_t;
using Integer64  = int64_t;
using Float32    = float;
using Float64    = double;
using String     = std::string;
// discourage 16bit types, CPUs aren't so efficient at these
// TODO: enums

/*
 
   about enums:
   
        Looks like C++17 might make reflection of enums nice.
            http://aantron.github.io/better-enums/demo/C++17ReflectionProposal.html
        In the mean time, something like this gets close with the use of an ugly macro where the enums are declared
        however it provides similar syntax to what C++17 may have for using the reflection
            http://melpon.org/wandbox/permlink/QelcwZNLi4gIx8Ux
 
 */

struct EnumBaseValue
{
  Integer32   id;
  String      name;
};


struct EnumBase
{
  String                name;
  Array<EnumBaseValue>  values;
};

#if 0

#if 1
template <class V, class T>
void Visit(V& v, T& var, typename V::Visit(T&))//, typename std::enable_if< ! std::is_function< decltype(T::Visit)(V&) >::value , T >::type* = 0 )
// typename std::enable_if< false /* !std::is_function<T::Visit>::value*/ >::type
//void Visit(V& v, T& var,  typename std::enable_if< std::is_function<T::Visit>::type , T >::type* = 0 )
{
  v.Visit(var);
}
#endif

template <class V, class T>
void Visit(V& v, T& var) // , typename T::Visit)
//, typename std::enable_if< std::is_function< decltype(T::Visit)(V&) >::value , T >::type* = 0 )
{
  var.Visit(v);
}

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);
}

#endif


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);
    Visit(var);
    Exit(name);
  }

  template <class T>
  void Visit(T& var)
  {
    var.Visit(*this);
  }

  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);
  }
  */
  template <class T>
  void Visit(const char* name, T& var)
  {
    Enter(name);
    Visit(var);
    Exit(name);
  }

  template <class T>
  void Visit(T& var)
  {
    var.Visit(*this);
  }

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);
    Visit(var);
  }

  template <class T>
  void Visit(T& var)
  {
    var.Visit(*this);
  }

  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);
    Visit(var);

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

  template <class T>
  void Visit(T& var)
  {
    var.Visit(*this);
  }

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
{
  Boolean        m_bool;
  Byte           m_uint8;
  Char           m_int8;
  Unsigned32     m_uint32;
  Unsigned64     m_uint64;
  Integer32      m_int32;
  Integer64      m_int64;
  Float32        m_flt32;
  Float64        m_flt64;

  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");
  }
};


/*
struct Employer
{
  String  name;
  
};
*/

/*
struct Property
{
  Property() : m_type(PT_Invalid) {}
  ~Property() {}

  explicit Property(Boolean    a_bool  ) : m_type(PT_Boolean   ) { m_basicType.m_bool   = a_bool  ; }
  explicit Property(Byte       a_uint8 ) : m_type(PT_Byte      ) { m_basicType.m_uint8  = a_uint8 ; }
  explicit Property(Char       a_int8  ) : m_type(PT_Char      ) { m_basicType.m_int8   = a_int8  ; }
  explicit Property(Unsigned32 a_uint32) : m_type(PT_Unsigned32) { m_basicType.m_uint32 = a_uint32; }
  explicit Property(Unsigned64 a_uint64) : m_type(PT_Unsigned64) { m_basicType.m_uint64 = a_uint64; }
  explicit Property(Integer32  a_int32 ) : m_type(PT_Integer32 ) { m_basicType.m_int32  = a_int32 ; }
  explicit Property(Integer64  a_int64 ) : m_type(PT_Integer64 ) { m_basicType.m_int64  = a_int64 ; }
  explicit Property(Float32    a_flt32 ) : m_type(PT_Float32   ) { m_basicType.m_flt32  = a_flt32 ; }
  explicit Property(Float64    a_flt64 ) : m_type(PT_Float64   ) { m_basicType.m_flt64  = a_flt64 ; }
  explicit Property(const Array<Property>& a_array ) : m_type(PT_Array ) { m_array      = a_array ; }
  explicit Property(const String&          a_string) : m_type(PT_String) { m_string     = a_string; }

  enum PropertyType
  {
    // Uninitialize state
    PT_Invalid    = 0,
    // Basic types
    PT_Boolean    = 1, 
    PT_Byte       = 2, 
    PT_Char       = 3, 
    PT_Unsigned32 = 4,
    PT_Unsigned64 = 5,
    PT_Integer32  = 6, 
    PT_Integer64  = 7, 
    PT_Float32    = 8, 
    PT_Float64    = 9, 
    // Complex types
    PT_Array      = 10,
    PT_String     = 11,
  };

  PropertyType     m_type;

  union {
    Boolean        m_bool;
    Byte           m_uint8;
    Char           m_int8;
    Unsigned32     m_uint32;
    Unsigned64     m_uint64;
    Integer32      m_int32;
    Integer64      m_int64;
    Float32        m_flt32;
    Float64        m_flt64;
  } m_basicType;

  Array<Property>  m_array;
  String           m_string;

  // 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("Property");
    Integer32 t = m_type;
    v.Visit("type", t);
    switch (m_type)
    {
      case PT_Boolean:
        v.Visit("value", m_basicType.m_bool); break;
      case PT_Byte:
        v.Visit("value", m_basicType.m_uint8); break;
      case PT_Char:
        v.Visit("value", m_basicType.m_int8); break;
      case PT_Unsigned32:
        v.Visit("value", m_basicType.m_uint32); break;
      case PT_Unsigned64:
        v.Visit("value", m_basicType.m_uint64); break;
      case PT_Integer32:
        v.Visit("value", m_basicType.m_int32); break;
      case PT_Integer64:
        v.Visit("value", m_basicType.m_int64); break;
      case PT_Float32:
        v.Visit("value", m_basicType.m_flt32); break;
      case PT_Float64:
        v.Visit("value", m_basicType.m_flt64); break;
      case PT_Array:
        v.Visit("value", m_array); break;
      case PT_String:
        v.Visit("value", m_string); break;
    }
    v.Exit("Property");
  }
};
*/


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;
    serializer.Visit(a);
    printf("%s", serializer.Output().c_str());
    input = serializer.Output();
  }

  {
    Person b;

    XMLDeserializerVisitor deserializer(input);
    deserializer.Visit(b);

    {
      XMLSerializerVisitor serializer;
      serializer.Visit(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;
    serializer.Visit(a);
    printf("%s", serializer.Output().c_str());
    input = serializer.Output();
  }

  {
    Person b;

    JsonDeserializerVisitor deserializer(input);
    deserializer.Visit(b);

    {
      JsonSerializerVisitor serializer;
      serializer.Visit(b);
      printf("%s", serializer.Output().c_str());
    }
  }
/*
  {  
    Property p("hello world");
    Property i(100);
    Array<Property> vals;
    vals.push_back(p);
    vals.push_back(i);
    Property a(vals);

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