#include <boost/config/warning_disable.hpp>
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_object.hpp>
#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/include/adapt_struct_named.hpp>
#include <boost/fusion/include/io.hpp>
#include <iostream>
#include <string>
#include <complex>

namespace bsq = boost::spirit::qi;
namespace bph = boost::phoenix;

struct SomeEnums
{
    enum CompareType
    {
        Exists      = 0x0000,
        NotExists   = 0x0001
    };
};

namespace client
{

struct UnaryExpression
{
    std::string key;
    SomeEnums::CompareType op;
};

}

BOOST_FUSION_ADAPT_STRUCT(
    client::UnaryExpression,
    (std::string, key)
    (SomeEnums::CompareType, op)
)

BOOST_FUSION_ADAPT_STRUCT_NAMED_NS(
    client::UnaryExpression,
    (client),
    UnaryFunction,
    (SomeEnums::CompareType, op)
    (std::string, key)
)

struct UnaryOps : bsq::symbols<char, SomeEnums::CompareType>
{
    UnaryOps() : bsq::symbols<char, SomeEnums::CompareType>(std::string("UnaryOps"))
    {
        add("exists", SomeEnums::Exists)
           ("nexists", SomeEnums::NotExists);
    }
};

namespace client
{
template<typename Iterator>
struct test_parser : bsq::grammar<Iterator, client::UnaryExpression(), bsq::ascii::space_type>
{
    test_parser()
        : test_parser::base_type(unaryExp, std::string("Test"))
    {
        using bsq::no_case;

        key %= bsq::lexeme[bsq::alnum >> +(bsq::alnum | bsq::char_('.'))];

        unaryExp %= unaryE | unaryF;
        unaryE %= key >> no_case[unaryOps];
        unaryF %= no_case[unaryOps] >> '(' >> key >> ')';
    };

    UnaryOps unaryOps;

    bsq::rule<Iterator, std::string(), bsq::ascii::space_type> key;
    bsq::rule<Iterator, client::UnaryExpression(), bsq::ascii::space_type> unaryExp;
    bsq::rule<Iterator, client::UnaryExpression(), bsq::ascii::space_type> unaryE;
    bsq::rule<Iterator, client::UnaryFunction(), bsq::ascii::space_type> unaryF;
};
}

int main(int argc, char ** argv)
{
    std::string str;

    while (std::getline(std::cin, str))
    {
        client::test_parser<std::string::const_iterator> parser;
        client::UnaryExpression exp;

        if (str.empty() || str[0] == 'q' || str[0] == 'Q')
            break;

        std::string::const_iterator iter = str.begin();
        std::string::const_iterator end = str.end();
        bool r = phrase_parse(iter, end, parser, bsq::ascii::space, exp);

        if (r && iter == end)
        {
            std::cout << "-------------------------\n";
            std::cout << "Parsing succeeded\n";
            std::cout << "key: " << exp.key << "\n";
            std::cout << "op : " << exp.op << "\n";
            std::cout << "-------------------------\n";
        }
        else
        {
            std::cout << "-------------------------\n";
            std::cout << "Parsing failed\n";
            std::cout << "-------------------------\n";
        }

        str.clear();
    }
    return 0;
}