#ifndef AST_HH
#define AST_HH

#include <string>
#include <typeinfo>
#include <vector>
#include "refcount.hh"

namespace AbSyn {

	class Term;
	class BindingTerm;
	class PairTerm;
	class AppTerm;
	class SkipTerm;
	class OpAppTerm;
	class OperatorDirective;
	class UseDirective;
	class Cases;
	class SeqTerm;
	class Symbol;
	class Fixity;
	class Form;
	
	class Visitor {
	public:
		virtual ~Visitor() {}

		virtual void symbol(Symbol *) = 0;
		virtual void binding(BindingTerm *) = 0;
		virtual void pair(PairTerm *) = 0;
		virtual void app(AppTerm *) = 0;
		virtual void seq(SeqTerm *) = 0;
		//virtual void cases(Cases *) = 0;
		virtual void form(Form *) = 0;
		virtual void skip(SkipTerm *) = 0;
		virtual void op(OpAppTerm *) {
			throw std::string("OP visited; not implemented");
		}
		virtual void opdirective(OperatorDirective *) {
			throw std::string("OP directive visited; not implemented");
		}
		virtual void usedirective(UseDirective *) {
			throw std::string("USE directive visited; not implemented");
		}
	};
	
	class AST {
		AST(AST const &);
		AST & operator=(AST const &);
	protected:
		AST() {}
	public:
		virtual ~AST() {}
		
		virtual Term & toTerm() throw (std::bad_cast) 
			{ throw std::bad_cast(); }
		virtual Cases & toCases() throw (std::bad_cast)
			{ throw std::bad_cast(); }
		virtual SeqTerm & toSeqTerm() throw (std::bad_cast)
			{ throw std::bad_cast(); }
		virtual Symbol & toSymbol() throw (std::bad_cast)
			{ throw std::bad_cast(); }
		virtual Fixity & toFixity() throw (std::bad_cast)
			{ throw std::bad_cast(); }
	};
	
	inline
	safe_ptr<Term> toTerm(safe_ptr<AST> ptr) 
		throw (std::bad_cast)
	{
		Term * tmp = &ptr.release()->toTerm();
		return safe_ptr<Term>(tmp);
	}

	inline
	safe_ptr<Cases> toCases(safe_ptr<AST> cases) 
		throw (std::bad_cast)
	{
		Cases * tmp = &cases.release()->toCases();
		return safe_ptr<Cases>(tmp);
	}
	
	inline
	safe_ptr<SeqTerm> toSeqTerm(safe_ptr<AST> cases) 
		throw (std::bad_cast)
	{
		SeqTerm * tmp = &cases.release()->toSeqTerm();
		return safe_ptr<SeqTerm>(tmp);
	}
	
	inline
	safe_ptr<Symbol> toSymbol(safe_ptr<AST> sym) 
		throw (std::bad_cast)
	{
		Symbol * tmp = &sym.release()->toSymbol();
		return safe_ptr<Symbol>(tmp);
	}
	
	inline
	safe_ptr<Fixity> toFixity(safe_ptr<AST> fix) 
		throw (std::bad_cast)
	{
		Fixity * tmp = &fix.release()->toFixity();
		return safe_ptr<Fixity>(tmp);
	}
	
	class Term : public AST {
		Term(Term const &);
		Term & operator=(Term const &);
		
		bool parenthesized;
	protected:
		Term() : parenthesized(false) {}
	public:
		void makeParenthesized() { parenthesized = true; }
		Term & toTerm() throw (std::bad_cast) { return *this; }

		virtual void accept(Visitor &) = 0;
	};
	
	class Symbol : public Term {
	public:
		typedef std::vector<std::string> path_t;
		Symbol(std::string sym, path_t path = path_t())
			: sym(sym), path(path)
			{}
		Symbol & toSymbol() throw (std::bad_cast) { return *this; }
		friend safe_ptr<Symbol> operator+(Symbol const & a,
						       Symbol const & b);
		
		safe_ptr<Symbol> no_path() const {
			return safe_ptr<Symbol>(new Symbol(sym));
		}
		
		virtual void accept(Visitor & v) { v.symbol(this); }

		std::string get_sym() const { return sym; }
		path_t const & get_path() const { return path; }
	private:
		std::string sym;
		path_t path;   

		Symbol(Symbol const &);
		Symbol & operator=(Symbol const &);
	};
	
	inline
	safe_ptr<Symbol> operator+(Symbol const & a,
				   Symbol const & b)
	{
		safe_ptr<Symbol> rv(new Symbol(b.sym, a.path));
		rv->path.insert(rv->path.end(), b.path.begin(), b.path.end());
		rv->path.insert(rv->path.end(), b.sym);
		return rv;
	}
	
	class BindingTerm : public Term {
		safe_ptr<Term> pat;
		safe_ptr<Term> val;
		bool exported;
		
		BindingTerm(BindingTerm const &);
		BindingTerm & operator=(BindingTerm const &);
	public:
		BindingTerm(safe_ptr<AST> pat, 
			    safe_ptr<AST> val,
			    bool exported = false) 
			: pat(::AbSyn::toTerm(pat)), 
			  val(::AbSyn::toTerm(val)),
			  exported(exported)
		{}

		bool get_exported() const { return exported; }
		Term & get_pat() const { return *pat; }
		Term & get_val() const { return *val; }

		void accept(Visitor & v) { v.binding(this); }
	};

	class PairTerm : public Term {
		safe_ptr<Term> left;
		safe_ptr<Term> right;
		
		PairTerm(PairTerm const &);
		PairTerm & operator=(PairTerm const &);
	public:
		PairTerm(safe_ptr<AST> left,
			 safe_ptr<AST> right)
			: left(::AbSyn::toTerm(left)), right(::AbSyn::toTerm(right))
			{}

		void accept(Visitor & v) { v.pair(this); }

		Term & get_left() const { return *left; }
		Term & get_right() const { return *right; }
	};
	
	class AppTerm : public Term {
		safe_ptr<Term> fun;
		safe_ptr<Term> arg;
		
		AppTerm(AppTerm const &);
		AppTerm & operator=(AppTerm const &);
	public:
		AppTerm(safe_ptr<AST> fun,
			safe_ptr<AST> arg)
			: fun(::AbSyn::toTerm(fun)), arg(::AbSyn::toTerm(arg))
			{}

		void accept(Visitor & v) { v.app(this); }

		Term & get_fun() const { return *fun; }
		Term & get_arg() const { return *arg; }
	};
	
	class OpAppTerm : public Term {
		safe_ptr<Symbol> op;
		safe_ptr<Term> larg;
		safe_ptr<Term> rarg;

		OpAppTerm(OpAppTerm const &);
		OpAppTerm & operator=(OpAppTerm const &);
	public:
		OpAppTerm(safe_ptr<AST> op,
			  safe_ptr<AST> larg,
			  safe_ptr<AST> rarg)
			: op(::AbSyn::toSymbol(op)),
			  larg(::AbSyn::toTerm(larg)),
			  rarg(::AbSyn::toTerm(rarg))
			{}

		Symbol & get_op() { return *op; }
		Term & get_larg() { return *larg; }
		Term & get_rarg() { return *rarg; }

		void accept(Visitor & v) { return v.op(this); }
	};

	class SeqTerm : public Term {
		std::vector<Term *> terms;

		SeqTerm(SeqTerm const &);
		SeqTerm & operator=(SeqTerm const &);
	public:
		SeqTerm(safe_ptr<AST> term) {
			append(term);
		}
		~SeqTerm() {
			for (std::vector<Term *>::iterator it = terms.begin();
			     it != terms.end(); ++it) {
				delete *it;
			}
		}
		SeqTerm & toSeqTerm() throw (std::bad_cast) { return *this; }
		void append(safe_ptr<AST> term) {
			terms.insert(terms.end(), &term->toTerm());
			term.release();
		}

		void accept(Visitor & v) { v.seq(this); }

		class iterator {
			friend class SeqTerm;
			std::vector<Term *>::iterator it;
			iterator(std::vector<Term *>::iterator it)
				: it(it)
				{}
		public:
			Term & operator*() { return **it; }
			Term * operator->() { return *it; }
			iterator & operator+=(int n) { it += n; return *this; }
			iterator & operator-=(int n) { it -= n; return *this; }
			iterator & operator++() { ++it; return *this; }
			iterator & operator--() { --it; return *this; }
			iterator   operator++(int) {
				iterator r = *this;
				it++;
				return r;
			}
			iterator   operator--(int) {
				iterator r = *this;
				it--;
				return r;
			}
			bool operator==(iterator const & other) const {
				return this->it == other.it;
			}
			bool operator< (iterator const & other) const {
				return this->it <  other.it;
			}
			bool operator> (iterator const & other) const {
				return this->it >  other.it;
			}
			bool operator<=(iterator const & other) const {
				return this->it <= other.it;
			}
			bool operator>=(iterator const & other) const {
				return this->it >= other.it;
			}
			bool operator!=(iterator const & other) const {
				return this->it != other.it;
			}
		};
		iterator begin() { return iterator(terms.begin()); }
		iterator end() { return iterator(terms.end()); }
	};

	class Cases : public AST {
		typedef std::pair<Term *, SeqTerm *> guard_t;
		typedef std::pair<Term *, std::vector<guard_t> > case_t;
		std::vector<case_t> cases;

		static const case_t empty_case;

		Cases(Cases const &);
		Cases & operator=(Cases const &);

		Cases(int) {}
	public:
		friend class generator;
		class generator {
			std::vector<case_t> & cases;
			std::vector<case_t>::iterator i;
			std::vector<guard_t>::iterator j;
		public:
			generator(Cases & cases)
				: cases(cases.cases),
				  i(cases.cases.begin())
				{}

			Term & current_pattern() { return *i->first; }
			Term & current_guard() { return *j->first; }
			Term & current_expr() { return *j->second; }

			void first_guard() { j = i->second.begin(); }
			void next_guard() { ++j; }
			bool last_guard() { return j == i->second.end(); }
			void first_case() { i = cases.begin(); }
			void next_case() { ++i; }
			bool last_case() { return i == cases.end(); }
		};

		generator gen() { return generator(*this); }

		static safe_ptr<AST> noCases() {
			return safe_ptr<AST>(new Cases(0));
		}

		Cases() {
			cases.insert(cases.begin(), empty_case);
		}

		~Cases() {
			for (std::vector<case_t>::iterator p = cases.begin();
			     p != cases.end();
			     ++p) {
				delete p->first;
				for (std::vector<guard_t>::iterator q
					     = p->second.begin();
				     q != p->second.end();
				     ++q) {
					delete q->first;
					delete q->second;
				}
			}
		}

		Cases & toCases() throw (std::bad_cast) { return *this; }

		void add_guard(safe_ptr<AST> guard_,
			       safe_ptr<AST> stmts_) {
			Term * guard = &guard_.release()->toTerm();
			SeqTerm * stmts = &stmts_.release()->toSeqTerm();
			std::vector<case_t>::iterator i = cases.end() - 1;
			i->second.insert(i->second.end(),
					 guard_t(guard, stmts));
		}
		void finish_case(safe_ptr<AST> pat_) {
			std::vector<case_t>::iterator i = cases.end() - 1;
			i->first = &pat_.release()->toTerm();
			cases.insert(cases.end(), empty_case);
		}
		void append(safe_ptr<AST> cases_) {
			safe_ptr<Cases> mcases = ::AbSyn::toCases(cases_);
			cases.erase(cases.end()-1);
			cases.insert(cases.end(), 
				     mcases->cases.begin(),
				     mcases->cases.end());
		}
		//void accept(Visitor & v) { v.cases(this); }
	};

	class Form : public Term {
		safe_ptr<SeqTerm> preamble;
		safe_ptr<Cases> cases;
		safe_ptr<Cases> catches;
		safe_ptr<SeqTerm> finally;

		Form(Form const &);
		Form & operator=(Form const &);
	public:
		Form(safe_ptr<AST> preamble,
		     safe_ptr<AST> cases,
		     safe_ptr<AST> catches,
		     safe_ptr<AST> finally)
			: preamble(::AbSyn::toSeqTerm(preamble)),
			  cases(::AbSyn::toCases(cases)),
			  catches(::AbSyn::toCases(catches)),
			  finally(::AbSyn::toSeqTerm(finally))
			{}

		void accept(Visitor & v) { v.form(this); }

		SeqTerm & get_preamble() { return *preamble; }
		Cases::generator cases_gen() { return cases->gen(); }
		Cases::generator catches_gen() { return catches->gen(); }
		SeqTerm & get_finally() { return *finally; }
	};

	class SkipTerm : public Term {
		SkipTerm(SkipTerm const &);
		SkipTerm & operator=(SkipTerm const &);
	public:
		SkipTerm() {}

		void accept(Visitor & v) { v.skip(this); }
	};

	inline
	safe_ptr<AST> skipTerm() {
		return safe_ptr<AST>(new SkipTerm());
	}
	
	template <typename T>
	class Vector : public AST {
		std::vector<T *> vec;
	public:
		~Vector() {
			for (typename std::vector<T *>::iterator it 
				     = vec.begin();
			     it != vec.end(); ++it) {
				delete *it;
			}
		}
		void append(safe_ptr<AST> p) {
			T * tmp = &dynamic_cast<T&>(*p);
			vec.insert(vec.end(), tmp);
		}
		void append(safe_ptr<T> p) {
			vec.insert(vec.end(), p);
		}
		void swap(Vector & other) {
			vec.swap(other.vec);
		}
	};
	
	class Fixity : public AST {
		Fixity(Fixity const &);
		Fixity & operator=(Fixity const &);
	public:
		Vector<Symbol> prec, succ;
		safe_ptr<Symbol> eqv;

		Fixity() {}

		Fixity & toFixity() throw (std::bad_cast) { return *this; }
	};

	class OperatorDirective : public Term {
	public:
		enum assoc_t { none, left, right };
		OperatorDirective(safe_ptr<AST> op,
				  assoc_t assoc, 
				  safe_ptr<AST> fixity) 
			: op(::AbSyn::toSymbol(op)),
			  assoc(assoc),
			  fix(::AbSyn::toFixity(op))
			{}
	private:
		safe_ptr<Symbol> op;
		assoc_t assoc;
		safe_ptr<Fixity> fix;

		OperatorDirective(OperatorDirective const &);
		OperatorDirective & operator=(OperatorDirective const &);

		void accept(Visitor & v) { v.opdirective(this); }
	};

	class UseDirective : public Term {
		safe_ptr<Symbol> sym;
		safe_ptr<Symbol> as;

		UseDirective(UseDirective const &);
		UseDirective & operator=(UseDirective const &);
	public:
		UseDirective(safe_ptr<AST> sym_)
			: sym(::AbSyn::toSymbol(sym_)),
			  as(sym->no_path())
			{}
		UseDirective(safe_ptr<AST> sym,
			     safe_ptr<AST> as)
			: sym(::AbSyn::toSymbol(sym)),
			  as(as->toSymbol().no_path())
			{}

		void accept(Visitor & v) { v.usedirective(this); }
	};

	class Module : public AST {
		safe_ptr<Symbol> name;
		safe_ptr<Term> body;

		Module(Module const &);
		Module & operator=(Module const &);
	public:
		Module(safe_ptr<AST> name,
		       safe_ptr<AST> body)
			: name(::AbSyn::toSymbol(name)),
			  body(::AbSyn::toTerm(body))
			{}
	};
}

namespace std {
	template <typename T>
	void swap(AbSyn::Vector<T> & a, AbSyn::Vector<T> & b)
	{
		a.swap(b);
	}
};


#endif /* AST_HH */