namespace Eva {
  public interface Term : Object {
    public abstract string to_string();
    
    public abstract void encode(Erl.Buffer buffer);
    
    public static Term decode(void *buffer) {
      int index = 0;
      int version;
      
      Erl.decode_version(buffer, ref index, out version);
      
      return do_decode(buffer, ref index);
    }
    
    private static Term do_decode(void *buffer, ref int index) {
      int type, size;
      assert(Erl.get_type(buffer, ref index, out type, out size) == 0);
      
      switch(type) {
      case Erl.TermType.SMALL_INTEGER:
        char value;
        assert(Erl.decode_char(buffer, ref index, out value) == 0);
        return new Int((uchar)value);
        
      case Erl.TermType.INTEGER:
        long value;
        assert(Erl.decode_long(buffer, ref index, out value) == 0);
        return new Int(value);
        
      case Erl.TermType.FLOAT:
        double value;
        assert(Erl.decode_double(buffer, ref index, out value) == 0);
        return new Double(value);
        
      case Erl.TermType.ATOM:
        char[] value = new char[size+1];
        assert(Erl.decode_atom(buffer, ref index, value) == 0);
        return new Atom(((string)value).ndup(size));
        
      case Erl.TermType.SMALL_TUPLE:
      case Erl.TermType.LARGE_TUPLE:
        assert(Erl.decode_tuple_header(buffer, ref index, out size) == 0);
        Tuple term = new Tuple();
        
        for(int i = 0; i < size; ++i) {
          term.value.add(do_decode(buffer, ref index));
        }
        
        return term;
        
      case Erl.TermType.NIL:
      case Erl.TermType.LIST:
        List term = new List();
        
        assert(Erl.decode_list_header(buffer, ref index, out size) == 0);
        if(size != 0) {
          for(int i = 0; i < size; ++i) {
            term.list.add(do_decode(buffer, ref index));
          }
        
          term.tail = do_decode(buffer, ref index);
        }
        
        return term;
        
      case Erl.TermType.STRING:
        char[] value = new char[size+1];
        assert(Erl.decode_string(buffer, ref index, value) == 0);
        return new String(((string)value).ndup(size));
        
      case Erl.TermType.BINARY:
        char[] value = new char[size];
        long l;
        assert(Erl.decode_binary(buffer, ref index, value, out l) == 0);
        return new Binary(value);
        
      case Erl.TermType.PID:
        Erl.Pid value;
        assert(Erl.decode_pid(buffer, ref index, out value) == 0);
        return new Pid(value);
        
      case Erl.TermType.PORT:
        Erl.Port value;
        assert(Erl.decode_port(buffer, ref index, out value) == 0);
        return new Port(value);
        
      case Erl.TermType.REFERENCE:
      case Erl.TermType.NEW_REFERENCE:
        Erl.Ref value;
        assert(Erl.decode_ref(buffer, ref index, out value) == 0);
        return new Ref(value);
        
      default:
        assert_not_reached();
      }
    }
  }
  
  public class Int : Object, Term {
    public long value {get; construct;}
    
    public Int(long v) {
      Object(value: v);
    }
    
    public string to_string() {
      return value.to_string();
    }
    
    public void encode(Erl.Buffer buffer) {
      buffer.encode_long(value);
    }
  }
  
  public class UInt : Object, Term {
    public ulong value {get; construct;}
    
    public UInt(ulong v) {
      Object(value: v);
    }
    
    public string to_string() {
      return value.to_string();
    }
    
    public void encode(Erl.Buffer buffer) {
      buffer.encode_ulong(value);
    }
  }
  
  public class Double : Object, Term {
    public double value {get; construct;}
    
    public Double(double v) {
      Object(value: v);
    }
    
    public string to_string() {
      return value.to_string();
    }
    
    public void encode(Erl.Buffer buffer) {
      buffer.encode_double(value);
    }
  }
  
  public class Atom : Object, Term {
    public string value {get; construct;}
    
    public Atom(string v) {
      Object(value: v);
    }
    
    public string to_string() {
      return value.to_string();
    }
    
    public void encode(Erl.Buffer buffer) {
      buffer.encode_atom(value.to_utf8());
    }
  }
  
  public class Tuple : Object, Term {
    public Gee.List<Term?> value {get; construct;}
    
    public Tuple() {
      Gee.List<Term?> list = new Gee.ArrayList<Term?>();
      Object(value: list);
    }
    
    public string to_string() {
      string ret = "{";
      bool first = true;
      
      foreach(Term term in value) {
        if(first) {
          first = false;
          ret += term.to_string();
        }
        else {
          ret += "," + term.to_string();
        }
      }
      
      return ret + "}";
    }
    
    public void encode(Erl.Buffer buffer) {
      buffer.encode_tuple_header(value.size);
      
      foreach(Term term in value) {
        term.encode(buffer);
      }
    }
  }
  
  public class List : Object, Term {
    private Term? _tail;
    
    public Gee.List<Term?> list {get; construct;}
    public Term? tail {
      get {
        return _tail;
      }
      set {
        if(value is List) {
          List l = value as List;
          
          list.add_all(l.list);
          _tail = l._tail;
        }
        else {
          _tail = value;
        }
      }
    }
    
    public List() {
      Gee.List<Term?> list0 = new Gee.LinkedList<Term?>();
      Object(list: list0);
      tail = null;
    }
    
    public string to_string() {
      string ret = "[";
      bool first = true;
      
      foreach(Term term in list) {
        if(first) {
          first = false;
          ret += term.to_string();
        }
        else {
          ret += "," + term.to_string();
        }
      }
      
      if(tail != null)
        ret += "|" + tail.to_string();
      
      return ret + "]";
    }
    
    public void encode(Erl.Buffer buffer) {
      if(!list.is_empty) {
        buffer.encode_list_header(list.size);
      
        foreach(Term term in list) {
          term.encode(buffer);
        }
      }
      
      buffer.encode_empty_list();
    }
  }
  
  public class String : Object, Term {
    public string value {get; construct;}
    
    public String(string v) {
      Object(value: v);
    }
    
    public string to_string() {
      return value.to_string();
    }
    
    public void encode(Erl.Buffer buffer) {
      buffer.encode_string(value.to_utf8());
    }
  }
  
  public class Binary : Object, Term {
    public void* value {get; private set;}
    public long len {get; private set;}
    
    public Binary(char[] v) {
      value = Memory.dup(v, (uint)(sizeof(char)*v.length));
      len = v.length;
    }
    
    public string to_string() {
      return "#Bin";
    }
    
    public void encode(Erl.Buffer buffer) {
      buffer.encode_binary((char*)value, len);
    }
  }
  
  public class Pid : Object, Term {
    public string node {get; construct;}
    public uint num {get; construct;}
    public uint serial {get; construct;}
    public uint creation {get; construct;}
    
    public Pid(Erl.Pid pid) {
      this.create(((string)pid.node).ndup(Erl.MAXATOMLEN), pid.num, pid.serial, pid.creation);
    }
    
    private Pid.create(string node0, uint num0, uint serial0, uint creation0) {
      Object(node: node0, num: num0, serial: serial0, creation: creation0);
    }
    
    public string to_string() {
      return "<" + node + "." + num.to_string() + "." + serial.to_string() + ">";
    }
    
    public void encode(Erl.Buffer buffer) {
      Erl.Pid pid = Erl.Pid();
      char[] nodedata = node.to_utf8();
      
      Memory.copy(pid.node, nodedata, int.min(Erl.MAXATOMLEN, nodedata.length));
      pid.node[int.min(Erl.MAXATOMLEN, nodedata.length)] = 0;
      
      pid.num = num;
      pid.serial = serial;
      pid.creation = creation;
      
      buffer.encode_pid(pid);
    }
  }

  public class Port : Object, Term {
    public string node {get; construct;}
    public uint id {get; construct;}
    public uint creation {get; construct;}
    
    public Port(Erl.Port port) {
      this.create(((string)port.node).ndup(Erl.MAXATOMLEN), port.id, port.creation);
    }
    
    private Port.create(string node0, uint id0, uint creation0) {
      Object(node: node0, id: id0, creation: creation0);
    }
    
    public string to_string() {
      return "#Port";
    }
    
    public void encode(Erl.Buffer buffer) {
      Erl.Port port = Erl.Port();
      char[] nodedata = node.to_utf8();
      
      Memory.copy(port.node, nodedata, int.min(Erl.MAXATOMLEN, nodedata.length));
      port.node[int.min(Erl.MAXATOMLEN, nodedata.length)] = 0;
      
      port.id = id;
      port.creation = creation;
      
      buffer.encode_port(port);
    }
  }
  
  public class Ref : Object, Term {
    public string node {get; construct;}
    public int len {get; construct;}
    public uint[] n {get; private set;}
    public uint creation {get; construct;}
    
    public Ref(Erl.Ref reference) {
      this.create(((string)reference.node).ndup(Erl.MAXATOMLEN), reference.len, reference.n, reference.creation);
    }
    
    private Ref.create(string node0, int len0, uint* n0, uint creation0) {
      Object(node: node0, len: len0, creation: creation0);
      
      n = new uint[len];
      for(int i = 0; i < len; ++i) {
        n[i] = n0[i];
      }
    }
    
    public string to_string() {
      return "#Ref";
    }
    
    public void encode(Erl.Buffer buffer) {
      Erl.Ref reference = Erl.Ref();
      char[] nodedata = node.to_utf8();
      
      Memory.copy(reference.node, nodedata, int.min(Erl.MAXATOMLEN, nodedata.length));
      reference.node[int.min(Erl.MAXATOMLEN, nodedata.length)] = 0;
      
      reference.len = len;
      
      for(int i = 0; i < len; ++i) {
        reference.n[i] = n[i];
      }
      
      reference.creation = creation;
      
      buffer.encode_ref(reference);
    }
  }
}