#ifndef PARSERGRAMMAR_HH_
#define PARSERGRAMMAR_HH_

#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>

#include "ExpressionContainer.hh"
#include "CustomFoldDirective.hh"

#include "ParserToolbox.hh"
#include "Properties.hh"

#include "FunctionInfo.hh"

namespace AMDA {
namespace parser {

namespace qi = boost::spirit::qi;

using namespace qi;
using namespace Expression;

template <typename It, typename Skipper = boost::spirit::standard_wide::space_type>

class ParserGrammar : public qi::grammar<It, Expression::ExpressionContainer(), Skipper>

{

public:

    ParserGrammar(AMDA::helpers::Properties& lProperties) : ParserGrammar::base_type(expr_)

    {
        expr_ = or_.alias();

	// Logical Operators

        or_ = fold<OrOperation>(and_.alias())[orOperator_ >> and_];
        and_ = fold<AndOperation>(equal_.alias())[andOperator_ >> equal_];
        equal_ = fold<EqualOperation>(unequal_.alias())[equalOperator_ >> unequal_]; 
        unequal_ = fold<UnequalOperation>(greaterOrEqual_.alias())[unequalOperator_ >>greaterOrEqual_];
        greaterOrEqual_ = fold<GreaterOrEqualOperation>(lowerOrEqual_.alias())[greaterOrEqualOperator_ >> lowerOrEqual_];
        lowerOrEqual_ = fold<LowerOrEqualOperation>(plusSign_.alias())[lowerOrEqualOperator_ >> plusSign_];                        

        plusSign_ = ((sumOperator_ >>-*sumOperator_)> minusSign_ ) [_val = boost::phoenix::construct<PlusSignOperation>(_1)] ||
                ((differenceOperator_ >>differenceOperator_)> minusSign_ ) [_val = boost::phoenix::construct<PlusSignOperation>(_1)] |minusSign_ [_val = _1];
        minusSign_ = (-*sumOperator_>>differenceOperator_ >>-*sumOperator_> sum_) [_val = boost::phoenix::construct<MinusSignOperation>(_1)] | sum_[_val = _1];

	// Numerical Operators

	sum_ = fold<SumOperation>(difference_.alias())[sumOperator_ >> difference_];
        difference_ = fold<DifferenceOperation>(powerTen_.alias())[differenceOperator_ >> powerTen_];
	powerTen_ = fold<PowerTenOperation>(division_.alias())[powerTenOperator_ >> division_];
        factor_ = fold<FactorOperation>(division_.alias())[factorOperator_ >> division_]; 
        division_ = fold<DivisionOperation>(pow_.alias())[divisionOperator_ >> pow_];

	pow_ = fold<funcop<op_power> >(greater_.alias())[powOperator_ >> greater_];

        greater_=  fold<GreaterOperation>(lower_.alias())[greaterOperator_ >> lower_];
        lower_ = fold<LowerOperation>( functions_.alias())[lowerOperator_ >> functions_];

        functions_ = (threeArgsFunction>>"(">>funArgs_>>componentOperator_>>funArgs_>>componentOperator_>>funArgs_>>")")[_val= boost::phoenix::construct<Expression::forop <fun_three>>(_1,_2,_3,_4)] ||
        (twoArgsFunction>>"(">>funArgs_>>componentOperator_>>funArgs_>>")")[_val= boost::phoenix::construct<Expression::triop <fun_two>>(_1,_2,_3)]||
        (oneArgsFunction>>"(">>funArgs_>>")")[_val= boost::phoenix::construct<Expression::binop <fun_one>>(_1,_2)]|not_[_val=_1];

	// UNARY OPERATIONS

	not_ = (notOperator_ > const_) [_val = boost::phoenix::construct<NotOperation>(_1)] | const_[_val = _1];

	const_ = (definedConstants) [_val = boost::phoenix::construct<ConstantOperation>(_1)] | param_[_val = _1];

 	param_= (definedParams >>('(' >> (spectArgs_|vectorArgs_)>>')'))[_val='$'+_1+"["+qi::_2+"]"] ||
                definedParams[_val='$'+_1]| simple[_val = _1];

        funArgs_=((expr_   |var_) |functions_); 

        simple = (('(' > expr_ > ')') | var_);

	var_ = (+qi::char_('0','9') >> -qi::char_('.') >> -(+qi::char_('0','9'))) | ((qi::char_('.') >> +qi::char_('0','9')));
	vectorArgs_%=qi::raw[qi::int_ > -(qi::char_(',')>>qi::int_) ];
        spectArgs_ %=qi::raw[(qi::int_>>qi::char_(',')>>'*')|(qi::char_('*')>>qi::char_(',')>>qi::int_)];
	powOperator_        = qi::char_('^');

	powerTenOperator_   = qi::char_('e');

        notOperator_        = qi::char_('!');

        andOperator_        = qi::string("&");
        orOperator_         = qi::string("|");

        equalOperator_      = qi::string("=");

        unequalOperator_    = qi::string("!=");

        sumOperator_        = qi::char_('+');
        differenceOperator_ = qi::char_('-');

        factorOperator_     = qi::char_("*");
        divisionOperator_   = qi::char_("/");
        greaterOperator_   = qi::char_(">");
        greaterOrEqualOperator_   = qi::string(">=");
        lowerOrEqualOperator_   = qi::string("<=");
        lowerOperator_   = qi::char_("<");

        componentOperator_   = qi::char_(",");

	// Define available constants
	std::map<std::string, std::string> existingConstants = ParserToolbox::getConstants(lProperties);
	for(std::map<std::string, std::string>::iterator it = existingConstants.begin(); it != existingConstants.end(); ++it) {

		definedConstants.add (it->first, it->second);

        }

	// Define available params
	std::vector<std::string> existingParams = ParserToolbox::getParameters(lProperties);
	for(std::vector<std::string>::iterator it = existingParams.begin(); it != existingParams.end(); ++it) {
		definedParams.add(*it,*it);
	}

       
        // Defined functions available 
        std::map<std::string,FunctionInfo> existingFunctions = ParserToolbox::getFunctions(lProperties);
        for(auto const& x : existingFunctions ) {
                if (x.second.getNbArgs()==1) {
                      oneArgsFunction.add(x.second.getIHMName(), x.second.getKernelName());
                }else if (x.second.getNbArgs()==2) {
                      twoArgsFunction.add(x.second.getIHMName(), x.second.getKernelName());
                }else {
                      threeArgsFunction.add(x.second.getIHMName(), x.second.getKernelName());
                }
        } 

        BOOST_SPIRIT_DEBUG_NODES((expr_)(or_)(and_)(equal_)(unequal_)(greaterOrEqual_)(lowerOrEqual_)(lower_)(sum_)
                (difference_)(factor_)(division_)(simple)(notOperator_)(andOperator_)(orOperator_)(equalOperator_)(unequalOperator_)

                (sumOperator_)(differenceOperator_)(factorOperator_)(divisionOperator_)(greater_)(lower_)(functions_));

    }

private:

    qi::rule<It, Expression::var(), Skipper> var_, vectorArgs_, spectArgs_;;

    qi::rule<It, Expression::ExpressionContainer(), Skipper> not_

        , pow_

	, powerTen_

        , and_

        , or_
        , equal_
        , unequal_
        , sum_
        , difference_
        , factor_
        , division_
        , simple
        , expr_
        ,plusSign_
        ,minusSign_

        ,greater_
        ,greaterOrEqual_
        ,lowerOrEqual_
        ,lower_

	,const_

	,param_
        ,functions_
        ,funArgs_;

    qi::rule<It, Skipper> notOperator_

	, powOperator_

	, powerTenOperator_

        , andOperator_
        , orOperator_

        , equalOperator_
        , unequalOperator_
        , sumOperator_
        , differenceOperator_
        , factorOperator_
        , divisionOperator_
        , greaterOperator_ 
        , greaterOrEqualOperator_ 
        ,lowerOrEqualOperator_

        ,componentOperator_

        ,lowerOperator_  ;

    qi::symbols<char, std::string> definedConstants;

    qi::symbols<char, std::string> definedParams;

    qi::symbols<char, std::string> twoArgsFunction;
    qi::symbols<char, std::string> oneArgsFunction;
        qi::symbols<char, std::string> threeArgsFunction;

};

}
}

#endif