#ifndef BOOST_NETWORK_CONSTANTS_HPP_20100808
#define BOOST_NETWORK_CONSTANTS_HPP_20100808

// Copyright 2010 (C) Dean Michael Berris
// 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/support/is_default_string.hpp>
#include <boost/network/support/is_default_wstring.hpp>
#include <boost/mpl/if.hpp>

namespace boost {
namespace network {

namespace impl {
template <class Tag>
struct constants_narrow {

  static char const* crlf() {
    static char crlf_[] = {'\r', '\n', 0};
    return crlf_;
  }

  static char const* dot() {
    static char dot_[] = {'.', 0};
    return dot_;
  }

  static char dot_char() { return '.'; }

  static char const* http_slash() {
    static char http_slash_[] = {'H', 'T', 'T', 'P', '/', 0};
    return http_slash_;
  }

  static char const* space() {
    static char space_[] = {' ', 0};
    return space_;
  }

  static char space_char() { return ' '; }

  static char const* slash() {
    static char slash_[] = {'/', 0};
    return slash_;
  }

  static char slash_char() { return '/'; }

  static char const* host() {
    static char host_[] = {'H', 'o', 's', 't', 0};
    return host_;
  }

  static char const* colon() {
    static char colon_[] = {':', 0};
    return colon_;
  }

  static char colon_char() { return ':'; }

  static char const* accept() {
    static char accept_[] = {'A', 'c', 'c', 'e', 'p', 't', 0};
    return accept_;
  }

  static char const* default_accept_mime() {
    static char mime_[] = {'*', '/', '*', 0};
    return mime_;
  }

  static char const* accept_encoding() {
    static char accept_encoding_[] = {'A', 'c', 'c', 'e', 'p', 't', '-', 'E',
                                      'n', 'c', 'o', 'd', 'i', 'n', 'g', 0};
    return accept_encoding_;
  }

  static char const* default_accept_encoding() {
    static char default_accept_encoding_[] = {
        'i', 'd', 'e', 'n', 't', 'i', 't', 'y', ';', 'q', '=',
        '1', '.', '0', ',', ' ', '*', ';', 'q', '=', '0', 0};
    return default_accept_encoding_;
  }

  static char const* user_agent() {
    static char user_agent_[] = {'U', 's', 'e', 'r', '-', 'A',
                                 'g', 'e', 'n', 't', 0};
    return user_agent_;
  }

  static char const* cpp_netlib_slash() {
    static char cpp_netlib_slash_[] = {'c', 'p', 'p', '-', 'n', 'e',
                                       't', 'l', 'i', 'b', '/', 0};
    return cpp_netlib_slash_;
  }

  static char question_mark_char() { return '?'; }

  static char hash_char() { return '#'; }

  static char const* connection() {
    static char connection_[] = {'C', 'o', 'n', 'n', 'e', 'c',
                                 't', 'i', 'o', 'n', 0};
    return connection_;
  }

  static char const* close() {
    static char close_[] = {'C', 'l', 'o', 's', 'e', 0};
    return close_;
  }

  static char const* https() {
    static char https_[] = "https";
    return https_;
  }
};

template <class Tag>
struct constants_wide {

  static wchar_t const* https() {
    static wchar_t https_[] = L"https";
    return https_;
  }
};
}

template <class Tag>
struct constants
    : mpl::if_<
          is_default_string<Tag>, impl::constants_narrow<Tag>,
          typename mpl::if_<is_default_wstring<Tag>, impl::constants_wide<Tag>,
                            unsupported_tag<Tag> >::type>::type {};

}  // namespace network

}  // namespace boost

#endif  // BOOST_NETWORK_CONSTANTS_HPP_20100808
