#pragma once

namespace pawn {

	namespace equ {

		template < class T >
		class IEvalable {
		public:
			virtual T eval() = 0;
		};

		template < class T >
		class Value : public IEvalable< T > {
			T _val;

		public:
			Value( T val )
				: _val( val ) { }

			virtual T eval() {
				return _val; }

			void set( T val ) {
				_val = val; }
		};

		enum {
			OP_ADD = 1,
			OP_SUB,
			OP_MUL,
			OP_DIV,
			OP_POW,
			OP_NEG,
			OP_SIN,
			OP_COS,
			OP_TAN,
			OP_ASIN,
			OP_ACOS,
			OP_ATAN,
			OP_LOG
		};
		
		template < class T >
		class UnaryExpression : public IEvalable< T > {
		protected:
			T _val;

		public:
			UnaryExpression( T val )
				: _val( val ) 
			{}
		};

		template < class T >
		class BinaryExpression : public IEvalable< T > {
		protected:
			T _val1;
			T _val2;

		public:
			BinaryExpression( T val1, T val2 )
				: _val1( val1 ),
				  _val2( val2 )
			{}
		};

		template < class T, unsigned int OP >
		class Expression : public IEvalable< T > { };

		template < class T >
		class Expression< T, OP_ADD > : public BinaryExpression< T > {

		};

		template < class T >
		class Expression< T, OP_SUB > : public BinaryExpression< T > {

		};

		template < class T >
		class Expression< T, OP_MUL > : public BinaryExpression< T > {

		};

		template < class T >
		class Expression< T, OP_DIV > : public BinaryExpression< T > {

		};

		template < class T >
		class Expression< T, OP_POW > : public BinaryExpression< T > {

		};

		template < class T >
		class Expression< T, OP_NEG > : public UnaryExpression< T > {

		};

		template < class T >
		class Expression< T, OP_SIN > : public UnaryExpression< T > {

		};

		template < class T >
		class Expression< T, OP_COS > : public UnaryExpression< T > {

		};

		template < class T >
		class Expression< T, OP_TAN > : public UnaryExpression< T > {

		};

		template < class T >
		class Expression< T, OP_ASIN > : public UnaryExpression< T > {

		};

		template < class T >
		class Expression< T, OP_ACOS > : public UnaryExpression< T > {

		};

		template < class T >
		class Expression< T, OP_ATAN > : public UnaryExpression< T > {

		};

		template < class T >
		class Expression< T, OP_LOG > : public BinaryExpression< T > {

		};

	}
}