/*=============================================================================
    Copyright (c) 2011 Alex Dubov

    Distributed under the Boost Software License, Version 1.0. (See accompanying
    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#if !defined(SPIRIT_MAP)
#define SPIRIT_MAP

#if defined(_MSC_VER)
#pragma once
#endif

#include <boost/spirit/home/qi/parser.hpp>
#include <boost/spirit/home/qi/detail/assign_to.hpp>
#include <boost/spirit/home/support/unused.hpp>
#include <boost/spirit/home/support/info.hpp>
#include <boost/spirit/home/support/common_terminals.hpp>
#include <boost/spirit/home/support/unused.hpp>
#include <boost/spirit/home/support/has_semantic_action.hpp>
#include <boost/spirit/home/support/assert_msg.hpp>
#include <map>
#include <iostream>

namespace boost { namespace spirit {
namespace repository
{
	BOOST_SPIRIT_DEFINE_TERMINALS_NAME_EX((map, map_type))
}

template <typename T, typename U>
struct use_directive<
	qi::domain,
	terminal_ex<repository::tag::map, fusion::vector1<std::map<T, U> > >
> : mpl::true_ {};

template <>
struct use_lazy_directive<qi::domain, repository::tag::map, 1> : mpl::true_ {};

namespace repository { namespace qi
{
	using repository::map_type;
	using repository::map;

	template <typename Subject, typename T, typename U>
	struct map_parser : spirit::qi::unary_parser<map_parser<Subject, T, U> >
	{
		template <typename Context, typename Iterator>
		struct attribute : mpl::identity<U> {};

		map_parser(Subject const& subject, std::map<T, U> const& lookup)
		: subject(subject), lookup(lookup) {}

		template <typename Iterator, typename Context, typename Skipper,
			  typename Attribute>
		bool parse(Iterator& first, Iterator const& last,
			   Context& context, Skipper const& skipper,
			   Attribute& attr) const
		{
			T attr_;

			Iterator iter = first;
			typename std::map<T, U>::const_iterator attr_iter;

			if (subject.parse(iter, last, context, skipper,
					  attr_)) {
				attr_iter = lookup.find(attr_);
				if (attr_iter != lookup.end()) {
					attr = attr_iter->second;
					first = iter;
					return true;
				}
			}
			return false;
		}

		template <typename Context>
		info what(Context const& ctx) const
		{
			return info("map", subject.what(ctx));
		}

		Subject subject;
		std::map<T, U> lookup;
	};
}}

namespace qi
{
	template <typename T, typename U, typename Subject, typename Modifiers>
	struct make_directive<
		terminal_ex<repository::tag::map,
			    fusion::vector1<std::map<T, U> > >,
		Subject, Modifiers
	>
	{
		typedef repository::qi::map_parser<Subject, T, U> result_type;

		template <typename Terminal>
		result_type operator()(
			Terminal const& term,
			Subject const& subject,
			Modifiers const& modifiers
		) const
		{
			return result_type(subject, fusion::at_c<0>(term.args));
		}
	};
}

namespace traits
{
	template <typename Subject, typename T, typename U>
	struct has_semantic_action<
		repository::qi::map_parser<Subject, T, U>
	> : unary_has_semantic_action<Subject> {};
}}}

#endif