/*=============================================================================
    Copyright (c) 2001-2014 Joel de Guzman

    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(BOOST_SPIRIT_X3_SEQUENCE_DETAIL_JAN_06_2013_1015AM)
#define BOOST_SPIRIT_X3_SEQUENCE_DETAIL_JAN_06_2013_1015AM

#include <boost/spirit/home/x3/support/traits/attribute_of.hpp>
#include <boost/spirit/home/x3/support/traits/attribute_category.hpp>
#include <boost/spirit/home/x3/support/traits/has_attribute.hpp>
#include <boost/spirit/home/x3/support/traits/is_substitute.hpp>
#include <boost/spirit/home/x3/support/traits/container_traits.hpp>
#include <boost/spirit/home/x3/support/traits/tuple_traits.hpp>
#include <boost/spirit/home/x3/core/detail/parse_into_container.hpp>

#include <boost/fusion/include/begin.hpp>
#include <boost/fusion/include/end.hpp>
#include <boost/fusion/include/advance.hpp>
#include <boost/fusion/include/deref.hpp>
#include <boost/fusion/include/empty.hpp>
#include <boost/fusion/include/front.hpp>
#include <boost/fusion/include/iterator_range.hpp>

#include <boost/mpl/if.hpp>

#include <boost/type_traits/add_reference.hpp>
#include <boost/type_traits/is_same.hpp>

#include <iterator> // for std::make_move_iterator

namespace boost {
namespace spirit {
namespace x3 {
template <typename Left, typename Right>
struct sequence;
}
}
}

namespace boost {
namespace spirit {
namespace x3 {
namespace detail {
template <typename Parser, typename Context, typename Enable = void>
struct sequence_size
{
    static int const value = traits::has_attribute<Parser, Context>::value;
};

template <typename Parser, typename Context>
struct sequence_size_subject
    : sequence_size<typename Parser::subject_type, Context> {};

template <typename Parser, typename Context>
struct sequence_size<Parser, Context
, typename enable_if_c<(Parser::is_pass_through_unary)>::type>
    : sequence_size_subject<Parser, Context> {};

template <typename L, typename R, typename Context>
struct sequence_size<sequence<L, R>, Context>
{
    static int const value =
        sequence_size<L, Context>::value +
        sequence_size<R, Context>::value;
};

struct pass_sequence_attribute_unused
{
    typedef unused_type type;

    template <typename T>
    static unused_type
    call(T&)
    {
        return unused_type();
    }
};

template <typename Attribute>
struct pass_sequence_attribute_size_one_view
{
    typedef typename fusion::result_of::deref<
    typename fusion::result_of::begin<Attribute>::type
    >::type type;

    static type
    call(Attribute& attribute)
    {
        return fusion::deref(fusion::begin(attribute));
    }
};

template <typename Attribute>
struct pass_through_sequence_attribute
{
    typedef Attribute& type;

    template <typename Attribute_>
    static Attribute_&
    call(Attribute_& attribute)
    {
        return attribute;
    }
};

template <typename Parser, typename Attribute, typename Enable = void>
struct pass_sequence_attribute :
    mpl::if_<
    traits::is_size_one_view<Attribute>
    , pass_sequence_attribute_size_one_view<Attribute>
    , pass_through_sequence_attribute<Attribute>>::type {};

template <typename L, typename R, typename Attribute>
struct pass_sequence_attribute<sequence<L, R>, Attribute>
    : pass_through_sequence_attribute<Attribute> {};

template <typename Parser, typename Attribute>
struct pass_sequence_attribute_subject :
    pass_sequence_attribute<typename Parser::subject_type, Attribute> {};

template <typename Parser, typename Attribute>
struct pass_sequence_attribute<Parser, Attribute
, typename enable_if_c<(Parser::is_pass_through_unary)>::type>
    : pass_sequence_attribute_subject<Parser, Attribute> {};

template <typename L, typename R, typename Attribute, typename Context
          , typename Enable = void>
struct partition_attribute
{
    using attr_category = typename traits::attribute_category<Attribute>::type;
    static_assert(is_same<traits::tuple_attribute, attr_category>::value,
                  "The parser expects tuple-like attribute type");

    static int const l_size = sequence_size<L, Context>::value;
    static int const r_size = sequence_size<R, Context>::value;

    static int constexpr actual_size = fusion::result_of::size<Attribute>::value;
    static int constexpr expected_size = l_size + r_size;

    // If you got an error here, then you are trying to pass
    // a fusion sequence with the wrong number of elements
    // as that expected by the (sequence) parser.
    static_assert(
        actual_size >= expected_size
    , "Size of the passed attribute is less than expected."
    );
    static_assert(
        actual_size <= expected_size
    , "Size of the passed attribute is bigger than expected."
    );

    typedef typename fusion::result_of::begin<Attribute>::type l_begin;
    typedef typename fusion::result_of::advance_c<l_begin, l_size>::type l_end;
    typedef typename fusion::result_of::end<Attribute>::type r_end;
    typedef fusion::iterator_range<l_begin, l_end> l_part;
    typedef fusion::iterator_range<l_end, r_end> r_part;
    typedef pass_sequence_attribute<L, l_part> l_pass;
    typedef pass_sequence_attribute<R, r_part> r_pass;

    static l_part
    left(Attribute& s)
    {
        auto i = fusion::begin(s);
        return l_part(i, fusion::advance_c<l_size>(i));
    }

    static r_part
    right(Attribute& s)
    {
        return r_part(
                   fusion::advance_c<l_size>(fusion::begin(s))
                   , fusion::end(s));
    }
};

template <typename L, typename R, typename Attribute, typename Context>
struct partition_attribute<L, R, Attribute, Context,
       typename enable_if_c<(!traits::has_attribute<L, Context>::value &&
                             traits::has_attribute<R, Context>::value)>::type>
       {
           typedef unused_type l_part;
           typedef Attribute& r_part;
           typedef pass_sequence_attribute_unused l_pass;
           typedef pass_sequence_attribute<R, Attribute> r_pass;

           static unused_type
           left(Attribute&)
{
    return unused;
}

static Attribute&
right(Attribute& s)
{
    return s;
}
       };

template <typename L, typename R, typename Attribute, typename Context>
struct partition_attribute<L, R, Attribute, Context,
       typename enable_if_c<(traits::has_attribute<L, Context>::value &&
                             !traits::has_attribute<R, Context>::value)>::type>
       {
           typedef Attribute& l_part;
           typedef unused_type r_part;
           typedef pass_sequence_attribute<L, Attribute> l_pass;
           typedef pass_sequence_attribute_unused r_pass;

           static Attribute&
           left(Attribute& s)
{
    return s;
}

static unused_type
right(Attribute&)
{
    return unused;
}
       };

template <typename L, typename R, typename Attribute, typename Context>
struct partition_attribute<L, R, Attribute, Context,
       typename enable_if_c<(!traits::has_attribute<L, Context>::value &&
                             !traits::has_attribute<R, Context>::value)>::type>
       {
           typedef unused_type l_part;
           typedef unused_type r_part;
           typedef pass_sequence_attribute_unused l_pass;
           typedef pass_sequence_attribute_unused r_pass;

           static unused_type
           left(Attribute&)
{
    return unused;
}

static unused_type
right(Attribute&)
{
    return unused;
}
       };

template <typename Parser, typename Iterator, typename Context
          , typename RContext, typename Attribute, typename AttributeCategory>
bool
parse_sequence(
    Parser const& parser, Iterator& first, Iterator const& last
    , Context const& context, RContext& rcontext, Attribute& attr
    , AttributeCategory)
{
    using Left = typename Parser::left_type;
    using Right = typename Parser::right_type;
    using partition = partition_attribute<Left, Right, Attribute, Context>;
    using l_pass = typename partition::l_pass;
    using r_pass = typename partition::r_pass;

    typename partition::l_part l_part = partition::left(attr);
    typename partition::r_part r_part = partition::right(attr);
    typename l_pass::type l_attr = l_pass::call(l_part);
    typename r_pass::type r_attr = r_pass::call(r_part);

    Iterator save = first;

    if (parser.left.parse(first, last, context, rcontext, l_attr)
            && parser.right.parse(first, last, context, rcontext, r_attr))
    {
        return true;
    }

    first = save;
    return false;
}

template <typename Parser, typename Context>
constexpr bool pass_sequence_container_attribute
    = sequence_size<Parser, Context>::value > 1;

template <typename Parser, typename Iterator, typename Context
          , typename RContext, typename Attribute>
typename enable_if_c<pass_sequence_container_attribute<Parser, Context>, bool>::type
parse_sequence_container(
    Parser const& parser
    , Iterator& first, Iterator const& last, Context const& context
    , RContext& rcontext, Attribute& attr)
{
    return parser.parse(first, last, context, rcontext, attr);
}

template <typename Parser, typename Iterator, typename Context
          , typename RContext, typename Attribute>
typename disable_if_c<pass_sequence_container_attribute<Parser, Context>, bool>::type
parse_sequence_container(
    Parser const& parser
    , Iterator& first, Iterator const& last, Context const& context
    , RContext& rcontext, Attribute& attr)
{
    return parse_into_container(parser, first, last, context, rcontext, attr);
}

template <typename Parser, typename Iterator, typename Context
          , typename RContext, typename Attribute>
bool
parse_sequence(
    Parser const& parser, Iterator& first, Iterator const& last
    , Context const& context, RContext& rcontext, Attribute& attr
    , traits::container_attribute)
{
    Iterator save = first;

    if (parse_sequence_container(parser.left, first, last, context, rcontext, attr)
            && parse_sequence_container(parser.right, first, last, context, rcontext, attr))
    {
        return true;
    }

    first = save;
    return false;
}

template <typename Parser, typename Iterator, typename Context
          , typename RContext, typename Attribute>
bool
parse_sequence_assoc(
    Parser const& parser, Iterator& first, Iterator const& last
    , Context const& context, RContext& rcontext, Attribute& attr, mpl::false_ /*should_split*/)
{
    return parse_into_container(parser, first, last, context, rcontext, attr);
}

template <typename Parser, typename Iterator, typename Context
          , typename RContext, typename Attribute>
bool
parse_sequence_assoc(
    Parser const& parser, Iterator& first, Iterator const& last
    , Context const& context, RContext& rcontext, Attribute& attr, mpl::true_ /*should_split*/)
{
    Iterator save = first;

    if (parser.left.parse( first, last, context, rcontext, attr)
            && parser.right.parse(first, last, context, rcontext, attr))
    {
        return true;
    }

    first = save;
    return false;
}

template <typename Parser, typename Iterator, typename Context
          , typename RContext, typename Attribute>
bool
parse_sequence(
    Parser const& parser, Iterator& first, Iterator const& last
    , Context const& context, RContext& rcontext, Attribute& attr
    , traits::associative_attribute)
{
    // we can come here in 2 cases:
    // - when sequence is key >> value and therefore must
    // be parsed with tuple synthesized attribute and then
    // that tuple is used to save into associative attribute provided here.
    // Example:  key >> value;
    //
    // - when either this->left or this->right provides full key-value
    // pair (like in case 1) and another one provides nothing.
    // Example:  eps >> rule<class x; fusion::map<...> >
    //
    // first case must be parsed as whole, and second one should
    // be parsed separately for left and right.

    typedef typename traits::attribute_of<
    decltype(parser.left), Context>::type l_attr_type;
    typedef typename traits::attribute_of<
    decltype(parser.right), Context>::type r_attr_type;

    typedef typename
    mpl::or_<
    is_same<l_attr_type, unused_type>
    , is_same<r_attr_type, unused_type> >
    should_split;

    return parse_sequence_assoc(parser, first, last, context, rcontext, attr
                                , should_split());
}

template <typename Left, typename Right, typename Context, typename RContext>
struct parse_into_container_impl<sequence<Left, Right>, Context, RContext>
{
    typedef sequence<Left, Right> parser_type;

    template <typename Iterator, typename Attribute>
    static bool
    call(
        parser_type const& parser
    , Iterator& first, Iterator const& last
    , Context const& context, RContext& rcontext, Attribute& attr, mpl::false_)
    {
        // inform user what went wrong if we jumped here in attempt to
        // parse incompatible sequence into fusion::map
        static_assert(!is_same< typename traits::attribute_category<Attribute>::type,
                      traits::associative_attribute>::value,
                      "To parse directly into fusion::map sequence must produce tuple attribute "
                      "where type of first element is existing key in fusion::map and second element "
                      "is value to be stored under that key");

        Attribute attr_{};

        if (!parse_sequence(parser
        , first, last, context, rcontext, attr_, traits::container_attribute()))
        {
            return false;
        }

        traits::append(attr, std::make_move_iterator(traits::begin(attr_)),
                       std::make_move_iterator(traits::end(attr_)));
        return true;
    }

    template <typename Iterator, typename Attribute>
    static bool
    call(
        parser_type const& parser
        , Iterator& first, Iterator const& last
        , Context const& context, RContext& rcontext, Attribute& attr, mpl::true_)
    {
        return parse_into_container_base_impl<parser_type>::call(
                   parser, first, last, context, rcontext, attr);
    }

    template <typename Iterator, typename Attribute>
    static bool
    call(
        parser_type const& parser
        , Iterator& first, Iterator const& last
        , Context const& context, RContext& rcontext, Attribute& attr)
    {
        typedef typename
        traits::attribute_of<parser_type, Context>::type
        attribute_type;

        typedef typename
        traits::container_value<Attribute>::type
        value_type;

        return call(parser, first, last, context, rcontext, attr
                    , typename traits::is_substitute<attribute_type, value_type>::type());
    }
};

}
}
}
}

#endif
