#ifndef EXPRESSIONS_H_
#define EXPRESSIONS_H_

#include <string>
#include <map>
#include <iostream>

using namespace std;

typedef enum {
	PREDICATE,
	NOT,
	AND,
	OR
} ExprType;

class Expression {
	public:
		virtual bool evaluate( ) = 0;
		virtual void print( ostream& o ) = 0;
		virtual ExprType type( ) = 0;
};

class NotExpression : public Expression {
	private:
		Expression *expr;

	public:
		NotExpression( Expression *_expr )
			: expr( _expr ) {
		}

		virtual bool evaluate( ) {
			return !expr->evaluate( );
		}

		virtual void print( ostream& o ) {
			bool is_parent = ( expr->type( ) == AND || expr->type( ) == OR );
			if( is_parent ) o << "(";
			o << "NOT ";
			expr->print( o );
			if( is_parent ) o << ")";
		}

		virtual ExprType type( ) {
			return NOT;
		}
};

class AndExpression : public Expression {
	private:
		Expression *expr;
		Expression *right;

	public:
		AndExpression( Expression *_expr, Expression *_right ) :
			expr( _expr ), right( _right ) {
		}

		virtual bool evaluate( ) {
			return expr->evaluate( ) && right->evaluate( );
		}

		virtual void print( ostream& o ) {
			bool is_parent = ( expr->type( ) == OR );
			if( is_parent ) o << "(";
			expr->print( o );
			if( is_parent ) o << ")";

			o << " AND ";

			is_parent = ( expr->type( ) == OR );
			if( is_parent ) o << "(";
			right->print( o );
			if( is_parent ) o << ")";
		}

		virtual ExprType type( ) {
			return AND;
		}
};

class OrExpression : public Expression {
	private:
		Expression *expr;
		Expression *right;

	public:
		OrExpression( Expression *_expr, Expression *_right ) :
			expr( _expr ), right( _right ) {
		}

		virtual bool evaluate( ) {
			return expr->evaluate( ) || right->evaluate( );
		}

		virtual void print( ostream& o ) {
			expr->print( o );
			o << " OR ";
			right->print( o );
		}

		virtual ExprType type( ) {
			return OR;
		}
};

class Predicate : public Expression {
	private:
		string ident;

	public:
		Predicate( const string _ident )
			: ident( _ident ) {
		}

		virtual bool evaluate( ) {
			return false;
		}

		virtual void print( ostream& o ) {
			o << ident;
		}

		virtual ExprType type( ) {
			return PREDICATE;
		}
};

class Expressions : public Expression {
	private:
		typedef map<string,bool> valueMap;
		valueMap values;

	public:
		Expressions( Expression *expr ) {
		}

		void setValue( const string ident, const bool value ) {
			values[ident] = value;
		}

		virtual bool evaluate( ) {
		}
};

#endif