#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
//#include <boost/variant/recursive_variant.hpp>
//#include <boost/foreach.hpp>

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

namespace client
{
	using namespace boost::spirit::qi;
	namespace fusion = boost::fusion;
	using namespace boost::phoenix;
	using namespace boost::spirit::ascii;

class Var
{
public:
	unsigned int Integer;
	std::string Name;
	unsigned int IsVar;//0=empty //1=Integer//2=Name;
};

class Term
{
public:
	Var Variable;
	std::vector<Term> Terme;
	unsigned int content;//0=empty //1= var //2= inv //3= add
};
class eq
{
public:
	Term Term1;
	Term Term2;
};
class eqList
{
public:
	std::vector<eq> equationList;
};
}

BOOST_FUSION_ADAPT_STRUCT(
    client::Var,
	(unsigned int, Integer)
	(std::string, Name)
	(unsigned int, IsVar)
	)

BOOST_FUSION_ADAPT_STRUCT(
    client::Term,
	(client::Var, Variable)
	(std::vector<client::Term>, Terme)
	(unsigned int, content)
)
BOOST_FUSION_ADAPT_STRUCT(
    client::eq,
	(client::Term, Term1)
	(client::Term, Term2)
)
BOOST_FUSION_ADAPT_STRUCT(
	client::eqList,
	(std::vector<client::eq>, equationList)
)

namespace client
{
    template <typename Iterator>
	struct skipper : grammar< Iterator,  ascii::space_type >
	{
		skipper() : skipper::base_type(skip_it)
		{
			skip_it =	boost::spirit::ascii::space 
						|lit('|')>> *( boost::spirit::ascii::char_ - eol )>> eol;
						
		}
		rule<Iterator, ascii::space_type> skip_it;

	};

	typedef BOOST_TYPEOF(lit('|')>> *( boost::spirit::ascii::space | boost::spirit::ascii::char_ - eol )>> eol ) skipper_type;
    template <typename Iterator>
    struct mini_eq_grammar : grammar<Iterator, eqList(), skipper_type>
    {
        mini_eq_grammar() : mini_eq_grammar::base_type(EqListR)
        {	/*Term=(Var)|('(+' Term ',' Term')')|('-'Term);*/
			VarR	=  uint_[at_c<0>(_val)=_1, at_c<2>(_val)=1] /*| string_[ref(Name)=_1,ref(IsVar)=2] */;
			TermR	=  VarR[at_c<0>(_val)=_1, at_c<2>(_val)=1]
					| (lit('(')>>lit('+')>> TermR[push_back(at_c<1>(_val),_1), at_c<2>(_val)=3]>> lit(',')>>  TermR[push_back(at_c<1>(_val),_1)] >>lit(')')) 
					|(lit('-')>>TermR[push_back(at_c<1>(_val),_1), at_c<2>(_val)=2]);
			EqR		=	TermR >> '=' >>TermR >>';';
			EqListR =  *EqR[push_back(at_c<0>(_val),_1)];
        }

        rule<Iterator, Var(), skipper_type> VarR;
		rule<Iterator, Term(), skipper_type> TermR;
		rule<Iterator, eq(), skipper_type> EqR;
		rule<Iterator, eqList(),skipper_type> EqListR;

    };



}

///////////////////////////////////////////////////////////////////////////////
//  Main program
///////////////////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{


    std::ifstream in("input.txt", std::ios_base::in);

    if (!in)
    {
        std::cerr << "Error: Could not open input file: "
            << "input.txt" << std::endl;
        return 1;
    }

    std::string storage; // We will read the contents here.
    //in.unsetf(std::ios::skipws); // No white space skipping!
    std::copy(
        std::istream_iterator<char>(in),
        std::istream_iterator<char>(),
        std::back_inserter(storage));
	//Fileoperations End

    typedef client::mini_eq_grammar<std::string::const_iterator> mini_eq_grammar;
	typedef client::skipper<std::string::const_iterator> skipper;
    mini_eq_grammar m_eq; // Our grammar
	skipper m_skipper;
	//client::eq equations; // Our tree
	client::eqList equations;

    using boost::spirit::ascii::space;
    std::string::const_iterator iter = storage.begin();
    std::string::const_iterator end = storage.end();
    bool r = phrase_parse(iter, end, m_eq, m_skipper, equations);

    if (r && iter == end)
    {
		std::cout<<"It worked... somehow"<<std::endl;


		return 0;
    }
    else
    {
        std::string::const_iterator some = iter+30;
        std::string context(iter, (some>end)?end:some);
        std::cout << "-------------------------\n";
        std::cout << "Parsing failed\n";
        std::cout << "stopped at: \": " << context << "...\"\n";
        std::cout << "-------------------------\n";
        return 1;
    }
}