// Copyright 2009, 2010, 2011, 2012 Dean Michael Berris, Jeroen Habraken, Glyn
// Matthews.
// 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)

#include <boost/network/uri/detail/uri_parts.hpp>
#include <boost/config/warning_disable.hpp>
#include <boost/spirit/home/qi.hpp>
#include <boost/fusion/adapted/struct/adapt_struct.hpp>

BOOST_FUSION_ADAPT_TPL_STRUCT(
    (FwdIter), (boost::network::uri::detail::hierarchical_part)(FwdIter),
    (boost::optional<boost::iterator_range<FwdIter> >,
     user_info)(boost::optional<boost::iterator_range<FwdIter> >,
                host)(boost::optional<boost::iterator_range<FwdIter> >,
                      port)(boost::optional<boost::iterator_range<FwdIter> >,
                            path));

BOOST_FUSION_ADAPT_TPL_STRUCT(
    (FwdIter), (boost::network::uri::detail::uri_parts)(FwdIter),
    (boost::iterator_range<FwdIter>,
     scheme)(boost::network::uri::detail::hierarchical_part<FwdIter>,
             hier_part)(boost::optional<boost::iterator_range<FwdIter> >,
                        query)(boost::optional<boost::iterator_range<FwdIter> >,
                               fragment));

namespace boost {
namespace network {
namespace uri {
namespace detail {
namespace qi = boost::spirit::qi;

template <class String>
struct uri_grammar
    : qi::grammar<typename String::const_iterator,
                  detail::uri_parts<typename String::const_iterator>()> {

  typedef String string_type;
  typedef typename String::const_iterator const_iterator;

  uri_grammar() : uri_grammar::base_type(start, "uri") {
    // gen-delims = ":" / "/" / "?" / "#" / "[" / "]" / "@"
    gen_delims %= qi::char_(":/?#[]@");
    // sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / ","
    // / ";" / "="
    sub_delims %= qi::char_("!$&'()*+,;=");
    // reserved = gen-delims / sub-delims
    reserved %= gen_delims | sub_delims;
    // unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
    unreserved %= qi::alnum | qi::char_("-._~");
    // pct-encoded = "%" HEXDIG HEXDIG
    pct_encoded %= qi::char_("%") >> qi::repeat(2)[qi::xdigit];

    // pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
    pchar %= qi::raw[unreserved | pct_encoded | sub_delims | qi::char_(":@")];

    // segment = *pchar
    segment %= qi::raw[*pchar];
    // segment-nz = 1*pchar
    segment_nz %= qi::raw[+pchar];
    // segment-nz-nc = 1*( unreserved / pct-encoded / sub-delims / "@" )
    segment_nz_nc %=
        qi::raw[+(unreserved | pct_encoded | sub_delims | qi::char_("@"))];
    // path-abempty  = *( "/" segment )
    path_abempty %= qi::raw[*(qi::char_("/") >> segment)];
    // path-absolute = "/" [ segment-nz *( "/" segment ) ]
    path_absolute %= qi::raw
        [qi::char_("/") >> -(segment_nz >> *(qi::char_("/") >> segment))];
    // path-rootless = segment-nz *( "/" segment )
    path_rootless %= qi::raw[segment_nz >> *(qi::char_("/") >> segment)];
    // path-empty = 0<pchar>
    path_empty %= qi::raw[qi::eps];

    // scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
    scheme %= qi::raw[qi::alpha >> *(qi::alnum | qi::char_("+.-"))];

    // user_info = *( unreserved / pct-encoded / sub-delims / ":" )
    user_info %=
        qi::raw[*(unreserved | pct_encoded | sub_delims | qi::char_(":"))];

    ip_literal %= qi::lit('[') >> (ipv6address | ipvfuture) >> ']';

    ipvfuture %=
        qi::lit('v') >> +qi::xdigit >> '.' >> +(unreserved | sub_delims | ':');

    ipv6address %= qi::raw
        [qi::repeat(6)[h16 >> ':'] >> ls32 |
         "::" >> qi::repeat(5)[h16 >> ':'] >> ls32 |
         -qi::raw[h16] >> "::" >> qi::repeat(4)[h16 >> ':'] >> ls32 |
         -qi::raw[h16] >> "::" >> qi::repeat(3)[h16 >> ':'] >> ls32 |
         -qi::raw[h16] >> "::" >> qi::repeat(2)[h16 >> ':'] >> ls32 |
         -qi::raw[h16] >> "::" >> h16 >> ':' >> ls32 |
         -qi::raw[h16] >> "::" >> ls32 | -qi::raw[h16] >> "::" >> h16 |
         -qi::raw[h16] >> "::" |
         -qi::raw[qi::repeat(1)[(h16 >> ':')] >> h16] >> "::" >>
             qi::repeat(3)[h16 >> ':'] >> ls32 |
         -qi::raw[qi::repeat(1)[(h16 >> ':')] >> h16] >> "::" >>
             qi::repeat(2)[h16 >> ':'] >> ls32 |
         -qi::raw[qi::repeat(1)[(h16 >> ':')] >> h16] >> "::" >> h16 >>
             ':' >> ls32 |
         -qi::raw[qi::repeat(1)[(h16 >> ':')] >> h16] >> "::" >> ls32 |
         -qi::raw[qi::repeat(1)[(h16 >> ':')] >> h16] >> "::" >> h16 |
         -qi::raw[qi::repeat(1)[(h16 >> ':')] >> h16] >> "::" |
         -qi::raw[qi::repeat(2)[(h16 >> ':')] >> h16] >> "::" >>
             qi::repeat(2)[h16 >> ':'] >> ls32 |
         -qi::raw[qi::repeat(2)[(h16 >> ':')] >> h16] >> "::" >> h16 >>
             ':' >> ls32 |
         -qi::raw[qi::repeat(2)[(h16 >> ':')] >> h16] >> "::" >> ls32 |
         -qi::raw[qi::repeat(2)[(h16 >> ':')] >> h16] >> "::" >> h16 |
         -qi::raw[qi::repeat(2)[(h16 >> ':')] >> h16] >> "::" |
         -qi::raw[qi::repeat(3)[(h16 >> ':')] >> h16] >> "::" >> h16 >>
             ':' >> ls32 |
         -qi::raw[qi::repeat(3)[(h16 >> ':')] >> h16] >> "::" >> ls32 |
         -qi::raw[qi::repeat(3)[(h16 >> ':')] >> h16] >> "::" >> h16 |
         -qi::raw[qi::repeat(3)[(h16 >> ':')] >> h16] >> "::" |
         -qi::raw[qi::repeat(4)[(h16 >> ':')] >> h16] >> "::" >> ls32 |
         -qi::raw[qi::repeat(4)[(h16 >> ':')] >> h16] >> "::" >> h16 |
         -qi::raw[qi::repeat(4)[(h16 >> ':')] >> h16] >> "::" |
         -qi::raw[qi::repeat(5)[(h16 >> ':')] >> h16] >> "::" >> h16 |
         -qi::raw[qi::repeat(5)[(h16 >> ':')] >> h16] >> "::" |
         -qi::raw[qi::repeat(6)[(h16 >> ':')] >> h16] >> "::"];

    // ls32 = ( h16 ":" h16 ) / IPv4address
    ls32 %= (h16 >> ':' >> h16) | ipv4address;

    // h16 = 1*4HEXDIG
    h16 %= qi::repeat(1, 4)[qi::xdigit];

    // dec-octet = DIGIT / %x31-39 DIGIT / "1" 2DIGIT / "2" %x30-34
    // DIGIT / "25" %x30-35
    dec_octet %= !(qi::lit('0') >> qi::digit) >>
                 qi::raw[qi::uint_parser<boost::uint8_t, 10, 1, 3>()];

    // IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet
    ipv4address %=
        qi::raw[dec_octet >> qi::repeat(3)[qi::lit('.') >> dec_octet]];

    // reg-name = *( unreserved / pct-encoded / sub-delims )
    reg_name %= qi::raw[*(unreserved | pct_encoded | sub_delims)];

    // TODO, host = IP-literal / IPv4address / reg-name
    host %= qi::raw[ip_literal | ipv4address | reg_name];

    // port %= qi::ushort_;
    port %= qi::raw[*qi::digit];

    // query = *( pchar / "/" / "?" )
    query %= qi::raw[*(pchar | qi::char_("/?"))];

    // fragment = *( pchar / "/" / "?" )
    fragment %= qi::raw[*(pchar | qi::char_("/?"))];

    // hier-part = "//" authority path-abempty / path-absolute /
    // path-rootless / path-empty
    // authority = [ userinfo "@" ] host [ ":" port ]
    hier_part %= ((("//" >> user_info >> '@') | "//") >> host >>
                  -(':' >> port) >> path_abempty) |
                 (qi::attr(iterator_range<const_iterator>()) >>
                  qi::attr(iterator_range<const_iterator>()) >>
                  qi::attr(iterator_range<const_iterator>()) >>
                  (path_absolute | path_rootless | path_empty));

    start %=
        (scheme >> ':') >> hier_part >> -('?' >> query) >> -('#' >> fragment);
  }

  qi::rule<const_iterator,
           typename iterator_range<const_iterator>::value_type()> gen_delims,
      sub_delims, reserved, unreserved;
  qi::rule<const_iterator, string_type()> pct_encoded, pchar;

  qi::rule<const_iterator, string_type()> segment, segment_nz, segment_nz_nc;
  qi::rule<const_iterator, iterator_range<const_iterator>()> path_abempty,
      path_absolute, path_rootless, path_empty;

  qi::rule<const_iterator, string_type()> dec_octet, ipv4address, reg_name,
      ipv6address, ipvfuture, ip_literal;

  qi::rule<const_iterator, string_type()> h16, ls32;

  qi::rule<const_iterator, iterator_range<const_iterator>()> host, port;

  qi::rule<const_iterator, iterator_range<const_iterator>()> scheme, user_info,
      query, fragment;

  qi::rule<const_iterator, hierarchical_part<const_iterator>()> hier_part;

  // actual uri parser
  qi::rule<const_iterator, uri_parts<const_iterator>()> start;
};

bool parse(std::string::const_iterator first, std::string::const_iterator last,
           uri_parts<std::string::const_iterator> &parts) {
  namespace qi = boost::spirit::qi;
  static detail::uri_grammar<std::string> grammar;
  bool is_valid = qi::parse(first, last, grammar, parts);
  return is_valid && (first == last);
}
}  // namespace detail
}  // namespace uri
}  // namespace network
}  // namespace boost
