#include <cstdlib>
#include <iostream>
#include <locale>
#include <string>

#include <boost/spirit/include/lex_lexertl.hpp>
#include <boost/spirit/include/phoenix_object.hpp >
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_statement.hpp>
#include <boost/spirit/include/phoenix_container.hpp>


namespace lex = boost::spirit::lex;
namespace phx = boost::phoenix;


enum tokenids 
{
	ID_IDENTIFICATOR = 1,
	ID_CONSTANT,
	ID_OPERATION,
	ID_BRACKET
};

template <typename Lexer>
struct mega_tokens
	: lex::lexer<Lexer>
{

	mega_tokens()
		: identifier(L"[a-zA-Z_][a-zA-Z0-9_]*", ID_IDENTIFICATOR)
		, constant  (L"[0-9]+(\\.[0-9]+)?",     ID_CONSTANT     )
		, operation (L"[\\+\\-\\*/]",           ID_OPERATION    )
		, bracket   (L"[\\(\\)\\[\\]]",         ID_BRACKET      )
	{
		using lex::_tokenid;
		using lex::_val;
		using phx::val;

		this->self
			= operation  [ std::wcout
                                << val(L'<') << _tokenid
                                << L':' << _val
                                << L'>'
                         ]
		    | identifier [ std::wcout
                                << val(L'<') << _tokenid
                                << L':' << _val
                                << L'>'
			             ]
            | constant   [ std::wcout
                                << val(L'<') << _tokenid
                                << L':' << _val
                                << L'>'
                         ]
			| bracket    [ std::wcout
                                << val(L'<') << _tokenid
                                << L':' << _val
                                << L'>'
                         ]
		;

	}

	lex::token_def<wchar_t,      wchar_t> operation;
	lex::token_def<std::wstring, wchar_t> identifier;
	lex::token_def<double,       wchar_t> constant;
	lex::token_def<wchar_t,      wchar_t> bracket;
};


int main()
{
	namespace lex = boost::spirit::lex;

	typedef std::wstring::iterator base_iterator;
	typedef lex::lexertl::token <
		base_iterator,
		boost::mpl::vector<wchar_t, std::wstring, double, wchar_t>,
		boost::mpl::true_
	> token_type;
	typedef lex::lexertl::actor_lexer<token_type> lexer_type;
	typedef mega_tokens<lexer_type>::iterator_type iterator_type;

	mega_tokens<lexer_type> mega_lexer;

	std::wstring exampleStr = L"alfa+x1*(2.836-x2[i])";
	base_iterator first = exampleStr.begin();

	bool r = lex::tokenize(first, exampleStr.end(), mega_lexer);

	if (r) {
		std::wcout << L"Success" << std::endl;
	}
	else {
		std::wstring rest(first, exampleStr.end());
		std::wcerr << L"Lexical analysis failed\n" << L"stopped at: \"" 
			<< rest << L"\"\n";
	}

	return EXIT_SUCCESS;
}