#include "cool-tree.h"
#include "emit.h"
#include "symtab.h"
#include <assert.h>
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <stdio.h>
#include <utility>
#include <vector>

enum Basicness { Basic, NotBasic };
#define TRUE 1
#define FALSE 0

class CgenClassTable;
typedef CgenClassTable *CgenClassTableP;

class CgenNode;
typedef CgenNode *CgenNodeP;

typedef std::vector<std::pair<class__class *, method_class *>> MethodListT;
typedef std::vector<attr_class *> AttrListT;

class CgenClassTable : public SymbolTable<Symbol, CgenNode> {
private:
  std::vector<CgenNode *> nodes;
  ostream &str;
  int stringclasstag;
  int intclasstag;
  int boolclasstag;

  // The following methods emit code for
  // constants and global declarations.

  void code_global_data();
  void code_global_text();
  void code_bools(int);
  void code_select_gc();
  void code_constants();

  // The following creates an inheritance graph from
  // a list of classes.  The graph is implemented as
  // a tree of `CgenNode', and class names are placed
  // in the base class symbol table.

  void install_basic_classes();
  void install_class(CgenNodeP nd);
  void install_classes(Classes cs);
  void build_inheritance_tree();
  void set_relations(CgenNodeP nd);
  //* New Methods
  void dump_inheritance_tree();
  void code_class_nameTable();
  void code_dispatchTable();
  void code_prototypeObject();
  CgenNode *get_node(Symbol);

public:
  CgenClassTable(Classes, ostream &str);
  void code();
  CgenNodeP root();
};

class CgenNode : public class__class {
private:
  CgenNodeP parentnd;               // Parent of class
  std::vector<CgenNode *> children; // Children of class
  Basicness basic_status;           // `Basic' if class is basic
                                    // `NotBasic' otherwise
  uint32_t _class_tag = 0;
  /* Allocate a class_tag on first scan increase in scanning order,
      starting from 1, so 0 is actually invalid by design
  */
  AttrListT attributes;
  // attr list including inherited
  MethodListT methods;
  // method list including inherited and overidden methods

public:
  CgenNode(Class_ c, Basicness bstatus, CgenClassTableP class_table);

  void add_child(CgenNodeP child);
  std::vector<CgenNode *> *get_children() { return &children; }
  void set_parentnd(CgenNodeP p);
  CgenNodeP get_parentnd() { return parentnd; }
  int basic() { return (basic_status == Basic); }
  uint32_t get_class_tag() { return _class_tag; }
  void set_class_tag(uint32_t val) { _class_tag = val; }
  void traverse_dump(int pad);
  uint32_t get_object_size() { return (3 + attributes.size()); }
  void traverse_generate_object();
  AttrListT *get_attributes() { return &attributes; };
  MethodListT *get_methods() { return &methods; };
};

class BoolConst {
private:
  int val;

public:
  BoolConst(int);
  void code_def(ostream &, int boolclasstag);
  void code_ref(ostream &) const;
};