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

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

class CgenClassTable;
typedef CgenClassTable *CgenClassTableP;

class CgenNode;
typedef CgenNode *CgenNodeP;

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
  */

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

class BoolConst {
private:
  int val;

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