#ifndef AST_H
#define AST_H
#include <vector>
#include <string>

class ast_node;
//class ast_visitor;
class Document;
class Block;
class Block_Table;
class Block_Code;
class Block_Line;
class Line;
class Word;
class Heading;
class List;
class MathDisp;
class Line_Word;
class Link;
class MathInline;
class Format;
class Format_Bold;
class Format_Italic;
class Format_Verbatim;
class Text;

class ast_visitor {
public:
	virtual void* visit_Document(Document *d)=0;
	virtual void* visit_Block_Table(Block_Table *bt)=0;
	virtual void* visit_Block_Code(Block_Code *bc)=0;
	virtual void* visit_Block_Line(Block_Line *bl)=0;
	virtual void* visit_Heading(Heading *h)=0;
	virtual void* visit_List(List *l)=0;
	virtual void* visit_MathDisp(MathDisp *md)=0;
	virtual void* visit_Line_Word(Line_Word *lw)=0;
	virtual void* visit_Link(Link *l)=0;
	virtual void* visit_MathInline(MathInline *mi)=0;
	virtual void* visit_Format_Bold(Format_Bold *fb)=0;
	virtual void* visit_Format_Italic(Format_Italic *fi)=0;
	virtual void* visit_Format_Verbatim(Format_Verbatim *fv)=0;
	virtual void* visit_Text(Text *t)=0;
};

class ast_node {
public:
	virtual ~ast_node()=default;
	virtual void* visit(ast_visitor *v)=0;
};

class Word: public ast_node {};

class MathInline: public Word {
	std::string *expr;
public:
	MathInline(std::string *e) {
		expr = e;
	}
	~MathInline() {
		delete expr;
	}
	std::string *get_expr() {
		return expr;
	}
	void* visit(ast_visitor *v) {
		return v->visit_MathInline(this);
	}
};

class Link: public Word {
	std::string *link, *text;
public:
	Link(std::string *l, std::string *t) {
		link = l;
		text = t;
	}
	~Link() {
		delete link;
		delete text;
	}
	std::string *get_link() {
		return link;
	}
	std::string *get_text() {
		return text;
	}
	void* visit(ast_visitor *v) {
		return v->visit_Link(this);
	}
};

class Format: public Word {};

class Text: public Format {
	std::string t;
public:
	Text(std::string tt) {
		t=tt;
	}
	std::string *get_text() {
		return &t;
	}
	void* visit(ast_visitor *v) {
		return v->visit_Text(this);
	}
};

class Format_Bold: public Format {
	Format *f;
public:
	Format_Bold(Format* ff) {
		f=ff;
	}
	~Format_Bold() {
		delete f;
	}
	Format *get_f() {
		return f;
	}
	void* visit(ast_visitor *v) {
		return v->visit_Format_Bold(this);
	}
};

class Format_Italic: public Format {
	Format *f;
public:
	Format_Italic(Format* ff) {
		f=ff;
	}
	~Format_Italic() {
		delete f;
	}
	Format *get_f() {
		return f;
	}
	void* visit(ast_visitor *v) {
		return v->visit_Format_Italic(this);
	}
};

class Format_Verbatim: public Format {
	Format *f;
public:
	Format_Verbatim(Format* ff) {
		f=ff;
	}
	~Format_Verbatim() {
		delete f;
	}
	Format *get_f() {
		return f;
	}
	void* visit(ast_visitor *v) {
		return v->visit_Format_Verbatim(this);
	}
};
class Line: public ast_node {};

class Heading: public Line {
	int level;
	std::vector<Word*> words;
public:
	Heading(int l, std::vector<Word*> w) {
		level = l;
		words = w;
	}
	~Heading() {
		for (std::vector<Word*>::size_type i = 0; i < words.size(); i++) {
			delete words[i];
		}
		words.clear();
	}
	int get_level() {
		return level;
	}
	std::vector<Word*>* get_words() {
		return &words;
	}
	void* visit(ast_visitor *v) {
		return v->visit_Heading(this);
	}
};

class List: public Line {
	int level, number;
	std::vector<Word*> words;
public:
	List(int l, int n, std::vector<Word*> w) {
		level = l;
		number = n;
		words = w;
	}
	~List() {
		for (std::vector<Word*>::size_type i = 0; i < words.size(); i++) {
			delete words[i];
		}
		words.clear();
	}
	int get_level() {
		return level;
	}
	int get_number() {
		return number;
	}
	std::vector<Word*>* get_words() {
		return &words;
	}
	void* visit(ast_visitor *v) {
		return v->visit_List(this);
	}
};

class MathDisp: public Line {
	std::string *expr;
public:
	MathDisp(std::string *e) {
		expr = e;
	}
	~MathDisp() {
		delete expr;
	}
	std::string *get_expr() {
		return expr;
	}
	void* visit(ast_visitor *v) {
		return v->visit_MathDisp(this);
	}
};

class Line_Word: public Line {
	std::vector<Word*> words;
public:
	~Line_Word() {
		for (std::vector<Word*>::size_type i = 0; i < words.size(); i++) {
			delete words[i];
		}
		words.clear();
	}
	int add_word(Word *w) {
		words.push_back(w);
		return 0;
	}
	std::vector<Word*> *get_words() {
		return &words;
	}
	void* visit(ast_visitor *v) {
		return v->visit_Line_Word(this);
	}
};

class Block: public ast_node {};

class Block_Table: public Block {
	std::vector<std::vector<Line_Word*>> table;
public:
	~Block_Table() {
		for (std::vector<std::vector<Line_Word*>>::size_type i = 0; i < table.size(); i++) {
			for (std::vector<Line_Word*>::size_type j = 0; j < table[i].size(); j++) {
				delete table[i][j];
			}
			table[i].clear();
		}
		table.clear();
	}
	std::vector<std::vector<Line_Word*>> get_table() {
		return table;
	}
	int add_row(std::vector<Line_Word*> row) {
		table.push_back(row);
		return 0;
	}
	void* visit(ast_visitor *v) {
		return v->visit_Block_Table(this);
	}
};

class Block_Code: public Block {
	std::string *c;
	std::string *lang;
public:
	Block_Code(std::string *l) {
		lang = l;
		c = new std::string();
	}
	~Block_Code() {
		delete c;
		delete lang;
	}
	int add_line(std::string *add) {
		*c = *c + *add + "\n";
		return 0;
	}
	std::string *get_lang() {
		return lang;
	}
	std::string *get_code() {
		return c;
	}
	void* visit(ast_visitor *v) {
		return v->visit_Block_Code(this);
	}
};

class Block_Line: public Block {
	std::vector<Line*> lines;
public:
	~Block_Line() {
		for (std::vector<Line*>::size_type i = 0; i < lines.size(); i++) {
			delete lines[i];
		}
		lines.clear();
	}
	std::vector<Line*> *get_lines() {
		return &lines;
	}
	int add_line(Line* l) {
		lines.push_back(l);
		return 0;
	}
	void* visit(ast_visitor *v) {
		return v->visit_Block_Line(this);
	}
};

class Document: public ast_node {
	std::string *title, *author, *date;
	std::vector<Block*> blocks;
public:
	Document(std::string *t, std::string *a, std::string *d) {
		title = t;
		author = a;
		date = d;
	}
	~Document() {
		for (std::vector<Block*>::size_type i = 0; i < blocks.size(); i++) {
			delete blocks[i];
		}
		blocks.clear();
		delete title;
		delete author;
		delete date;
	}
	std::string *get_title() {
		return title;
	}
	std::string *get_author() {
		return author;
	}
	std::string *get_date() {
		return date;
	}
	std::vector<Block*> *get_blocks() {
		return &blocks;
	}
	int add_block(Block *b) {
		blocks.push_back(b);
		return 0;
	}
	void* visit(ast_visitor *v) {
		return v->visit_Document(this);
	}

};
#endif