#ifndef _utl_UnitGrammar_h
#define _utl_UnitGrammar_h

/*!
  \file UnitGrammar.h

  \brief Unit evaluating grammar definition

  \author Roland Sipos
*/

#include <boost/version.hpp>
#if BOOST_VERSION >= 103800
#  define BOOST_SPIRIT_USE_OLD_NAMESPACE
#  include <boost/spirit/include/classic.hpp>
#  include <boost/spirit/include/phoenix1_binders.hpp>
#  include <boost/spirit/include/phoenix1_functions.hpp>
#else
#  include <boost/spirit.hpp>
#  include <boost/spirit/phoenix/binders.hpp>
#  include <boost/spirit/phoenix/primitives.hpp>
#  include <boost/spirit/phoenix/functions.hpp>
#endif

#include <string>
#include <map>
#include <math.h>

namespace utl {

  // Raise X to power of Y template
  struct PowerToImpl {
    template<typename T1, typename T2>
    struct result { typedef double type; };

    template<typename T1, typename T2>
    T1 operator()(T1& t1, T2& t2) const
    { return std::pow(t1, t2); }
  };


  // Create it as a constant Phoenix Function
  const phoenix::function<PowerToImpl> power = PowerToImpl();


  // Unit Grammar Structure
  struct UnitGrammar : public boost::spirit::grammar<UnitGrammar> {

    typedef std::map<std::string, double> SymbolTable;

    enum EErrors {
      eOk,        // Everything is ok
      eLookup,    // Could not find symbol in table
      eBracket,   // Bracket error
      eBadSymbol, // Wrong token, e.g. plus or minus
      eParsing,   // Unknown parsing problem
    };

    UnitGrammar(const SymbolTable& symbols, double& retval, EErrors& error)
      : fSymbols(symbols), fResult(retval), fError(error) { }

    //! Value closure set
    struct SValueClosure : public boost::spirit::closure<SValueClosure, double> {
      member1 value;
    };

    //! Assignment closure set
    struct SAssignmentClosure : public boost::spirit::closure<SAssignmentClosure, std::string, double> {
      member1 name;
      member2 value;
    };

    //! String closure set
    struct SStringClosure : public boost::spirit::closure<SStringClosure, std::string> {
      member1 name;
    };

    //! Boost spirit definition template (Read Boost Spirit documentation)
    template<typename ScannerT>
    struct definition {
      definition(UnitGrammar const& self)
      {
        group
          = '('
          >> expression[group.value = phoenix::arg1]
          >> ')'
        ;

        identifier
          = boost::spirit::lexeme_d[(boost::spirit::alpha_p | '_')
          >> *(boost::spirit::alnum_p | '_')][
            identifier.name = phoenix::construct_<std::string>(phoenix::arg1, phoenix::arg2)
          ]
        ;

        statement
          = expression[phoenix::bind(&UnitGrammar::SaveResult)(self, phoenix::arg1)]
          >> (boost::spirit::end_p | ';')
        ;

        literal
          = boost::spirit::longest_d[boost::spirit::int_p[literal.value = phoenix::arg1]
          | boost::spirit::real_p[literal.value = phoenix::arg1]]
        ;

        factor
          = literal[factor.value = phoenix::arg1]
          | group[factor.value = phoenix::arg1]
          | identifier[factor.value = phoenix::bind(&UnitGrammar::Lookup)(self, phoenix::arg1)]
        ;

        term
          = factor[term.value = phoenix::arg1] >>
          *(
            ('^' >> factor[term.value = power(term.value, phoenix::arg1)])
          )
        ;

        expression
          = term[expression.value = phoenix::arg1] >>
          *(
            ('*' >> term[expression.value *= phoenix::arg1])
            | ('/' >> term[expression.value /= phoenix::arg1])
          )
        ;

      }

      boost::spirit::rule<ScannerT> const& start() const { return statement; }
      boost::spirit::rule<ScannerT> statement;
      boost::spirit::rule<ScannerT, SStringClosure::context_t> identifier;
      boost::spirit::rule<ScannerT, SValueClosure::context_t> expression, factor, group, literal, term;
    };

    void SaveResult(double val) const { fResult = val; }

    //! Function which searches in the symbol table
    double
    Lookup(const std::string& variable)
      const
    {
      const SymbolTable::const_iterator it = fSymbols.find(variable);
      if (it == fSymbols.end()) {
        fError = eLookup;
        return 1;
      } else {
        return it->second;
      }
    }

  private:
    const SymbolTable& fSymbols;
    double& fResult;
    EErrors& fError;
  };

}


#endif