#ifndef __NODE_HPP_
#define __NODE_HPP_

#include <string>
#include <iostream>
#include <vector>

#include <llvm/IR/Value.h>

class NStatement;
class NExpression;
class NVariableDeclaration;
class CodeGenContext;

typedef std::vector<NStatement *> StatementList;
typedef std::vector<NExpression *> ExpressionList;
typedef std::vector<NVariableDeclaration*> VariableList;

// abstract type, never constructuted, defines the public interface to the AST
class Node {
	public:
		virtual ~Node( ) { }

		friend std::ostream& operator<<( std::ostream& o, const Node& n );
	
		virtual void printTo( std::ostream& o ) const;

		virtual llvm::Value* codeGen( CodeGenContext& context );
};

// an expression
class NExpression : public Node
{
};

// a block of statements
class NBlock : public NExpression
{
	public:
		StatementList m_statements;
		
		virtual void printTo( std::ostream& o ) const;
		virtual llvm::Value* codeGen( CodeGenContext& context );
};

class NStatement : public Node
{
	public:
		virtual void printTo( std::ostream& o ) const;
};

class NExpressionStatement : public NStatement
{
	public:
		NExpression& m_expression;

		NExpressionStatement( NExpression& _expression ) : m_expression( _expression ) { }

		virtual void printTo( std::ostream& o ) const;
		virtual llvm::Value* codeGen( CodeGenContext& context );
};

// simple integer constant
class NInteger : public NExpression
{
	public:
		int m_value;
		
		NInteger( int _value ) : m_value( _value ) { }

		virtual void printTo( std::ostream& o ) const;
		virtual llvm::Value* codeGen( CodeGenContext& context );
};

class NIdentifier : public Node
{
	public:
		std::string m_name;
		NIdentifier( const std::string& _name ) : m_name( _name ) { }
		virtual void printTo( std::ostream& o ) const;
		virtual llvm::Value* codeGen( CodeGenContext& context );
};

class NAssignment : public NExpression
{
	public:
		NIdentifier& m_lhs;
		NExpression& m_rhs;
		
		NAssignment( NIdentifier& _lhs, NExpression& _rhs ) : m_lhs( _lhs ), m_rhs( _rhs ) { }

		virtual void printTo( std::ostream& o ) const;
		virtual llvm::Value* codeGen( CodeGenContext& context );
};

class NVariableDeclaration : public NStatement
{
	public:
		const NIdentifier& m_type;
		NIdentifier& m_name;
		NExpression *m_assigned_expr;
		
		NVariableDeclaration( const NIdentifier& _type, NIdentifier& _name )
			: m_type( _type ), m_name( _name ), m_assigned_expr( 0 )
		{
		}

		NVariableDeclaration( const NIdentifier& _type, NIdentifier& _name, NExpression *_assigned_expr )
			: m_type( _type ), m_name( _name ), m_assigned_expr( _assigned_expr )
		{
		}		

		virtual void printTo( std::ostream& o ) const;
		virtual llvm::Value* codeGen( CodeGenContext& context );
};

class NFunctionDeclaration : public NStatement
{
	public:
		const NIdentifier& m_type;
		const NIdentifier& m_name;
		VariableList m_arguments;
		NBlock& m_block;
		
		NFunctionDeclaration( const NIdentifier& _type, const NIdentifier& _name,
			const VariableList& _arguments, NBlock& _block )
			: m_type( _type ), m_name( _name ), m_arguments( _arguments ), m_block( _block )
		{
		}
		
		virtual void printTo( std::ostream& o ) const;
		virtual llvm::Value* codeGen( CodeGenContext& context );
};

class NFunctionCall : public NExpression
{
	public:
		const NIdentifier& m_name;
		ExpressionList m_arguments;
		
		NFunctionCall( const NIdentifier& _name, ExpressionList& _arguments )
			: m_name( _name ), m_arguments( _arguments )
		{
		}
		
		NFunctionCall( const NIdentifier& _name ) : m_name( _name ) { }

		virtual void printTo( std::ostream& o ) const;
		virtual llvm::Value* codeGen( CodeGenContext& context );
};

class NBinaryOperator : public NExpression {
	public:
		NExpression& m_lhs;
		NExpression& m_rhs;
		int m_op;
		
		NBinaryOperator( NExpression& _lhs, int _op, NExpression& _rhs )
			: m_lhs( _lhs ), m_rhs( _rhs ), m_op( _op )
		{
		}
		
		virtual void printTo( std::ostream& o ) const;
		virtual llvm::Value* codeGen( CodeGenContext& context );
};


#endif //__NODE_HPP_