    // Copyright (C) 2003  Davis E. King (davis@dlib.net)
    // License: Boost Software License   See LICENSE.txt for the full license.
    #ifndef DLIB_SERVER_HTTP_CPp_
    #define DLIB_SERVER_HTTP_CPp_

    #include "server_http.h"

    namespace dlib
    {

    // ----------------------------------------------------------------------------------------

        namespace http_impl
        {
            inline unsigned char to_hex( unsigned char x )
            {
                return x + (x > 9 ? ('A'-10) : '0');
            }

            const std::string urlencode( const std::string& s )
            {
                std::ostringstream os;

                for ( std::string::const_iterator ci = s.begin(); ci != s.end(); ++ci )
                {
                    if ( (*ci >= 'a' && *ci <= 'z') ||
                         (*ci >= 'A' && *ci <= 'Z') ||
                         (*ci >= '0' && *ci <= '9') )
                    { // allowed
                        os << *ci;
                    }
                    else if ( *ci == ' ')
                    {
                        os << '+';
                    }
                    else
                    {
                        os << '%' << to_hex(*ci >> 4) << to_hex(*ci % 16);
                    }
                }

                return os.str();
            }

            inline unsigned char from_hex (
                unsigned char ch
            )
            {
                if (ch <= '9' && ch >= '0')
                    ch -= '0';
                else if (ch <= 'f' && ch >= 'a')
                    ch -= 'a' - 10;
                else if (ch <= 'F' && ch >= 'A')
                    ch -= 'A' - 10;
                else
                    ch = 0;
                return ch;
            }

            const std::string urldecode (
                const std::string& str
            )
            {
                using namespace std;
                string result;
                string::size_type i;
                for (i = 0; i < str.size(); ++i)
                {
                    if (str[i] == '+')
                    {
                        result += ' ';
                    }
                    else if (str[i] == '%' && str.size() > i+2)
                    {
                        const unsigned char ch1 = from_hex(str[i+1]);
                        const unsigned char ch2 = from_hex(str[i+2]);
                        const unsigned char ch = (ch1 << 4) | ch2;
                        result += ch;
                        i += 2;
                    }
                    else
                    {
                        result += str[i];
                    }
                }
                return result;
            }

            void parse_url(
                std::string word,
                key_value_map& queries
            )
            /*!
                Parses the query string of a URL.  word should be the stuff that comes
                after the ? in the query URL.
            !*/
            {
                std::string::size_type pos;

                for (pos = 0; pos < word.size(); ++pos)
                {
                    if (word[pos] == '&')
                        word[pos] = ' ';
                }

                std::istringstream sin(word);
                sin >> word;
                while (sin)
                {
                    pos = word.find_first_of("=");
                    if (pos != std::string::npos)
                    {
                        std::string key = urldecode(word.substr(0,pos));
                        std::string value = urldecode(word.substr(pos+1));

                        queries[key] = value;
                    }
                    sin >> word;
                }
            }

            void read_with_limit(
                std::istream& in,
                std::string& buffer,
                int delim = '\n'
            )
            {
                using namespace std;
                const size_t max = 64*1024;
                buffer.clear();
                buffer.reserve(300);

                while (in.peek() != delim && in.peek() != '\n' && in.peek() != EOF && buffer.size() < max)
                {
                    buffer += (char)in.get();
                }

                // if we quit the loop because the data is longer than expected or we hit EOF
                if (in.peek() == EOF)
                    throw http_parse_error("HTTP field from client terminated incorrectly", 414);
                if (buffer.size() == max)
                    throw http_parse_error("HTTP field from client is too long", 414);

                in.get();
                // eat any remaining whitespace
                if (delim == ' ')
                {
                    while (in.peek() == ' ')
                        in.get();
                }
            }
        }

    // ----------------------------------------------------------------------------------------

        unsigned long parse_http_request (
            std::istream& in,
            incoming_things& incoming,
            unsigned long max_content_length
        )
        {
            using namespace std;
            using namespace http_impl;
            read_with_limit(in, incoming.request_type, ' ');

            // get the path
            read_with_limit(in, incoming.path, ' ');

            // Get the HTTP/1.1 - Ignore for now...
            read_with_limit(in, incoming.protocol);

            key_value_map_ci& incoming_headers = incoming.headers;
            key_value_map& cookies          = incoming.cookies;
            std::string& path               = incoming.path;
            std::string& content_type       = incoming.content_type;
            unsigned long content_length = 0;

            string line;
            read_with_limit(in, line);
            string first_part_of_header;
            string::size_type position_of_double_point;
            // now loop over all the incoming_headers
            while (line != "\r")
            {
                position_of_double_point = line.find_first_of(':');
                if ( position_of_double_point != string::npos )
                {
                    first_part_of_header = dlib::trim(line.substr(0, position_of_double_point));

                    if ( !incoming_headers[first_part_of_header].empty() )
                        incoming_headers[ first_part_of_header ] += " ";
                    incoming_headers[first_part_of_header] += dlib::trim(line.substr(position_of_double_point+1));

                    // look for Content-Type:
                    if (line.size() > 14 && strings_equal_ignore_case(line, "Content-Type:", 13))
                    {
                        content_type = line.substr(14);
                        if (content_type[content_type.size()-1] == '\r')
                            content_type.erase(content_type.size()-1);
                    }
                    // look for Content-Length:
                    else if (line.size() > 16 && strings_equal_ignore_case(line, "Content-Length:", 15))
                    {
                        istringstream sin(line.substr(16));
                        sin >> content_length;
                        if (!sin)
                        {
                            throw http_parse_error("Invalid Content-Length of '" + line.substr(16) + "'", 411);
                        }

                        if (content_length > max_content_length)
                        {
                            std::ostringstream sout;
                            sout << "Content-Length of post back is too large.  It must be less than " << max_content_length;
                            throw http_parse_error(sout.str(), 413);
                        }
                    }
                    // look for any cookies
                    else if (line.size() > 6 && strings_equal_ignore_case(line, "Cookie:", 7))
                    {
                        string::size_type pos = 6;
                        string key, value;
                        bool seen_key_start = false;
                        bool seen_equal_sign = false;
                        while (pos + 1 < line.size())
                        {
                            ++pos;
                            // ignore whitespace between cookies
                            if (!seen_key_start && line[pos] == ' ')
                                continue;

                            seen_key_start = true;
                            if (!seen_equal_sign)
                            {
                                if (line[pos] == '=')
                                {
                                    seen_equal_sign = true;
                                }
                                else
                                {
                                    key += line[pos];
                                }
                            }
                            else
                            {
                                if (line[pos] == ';')
                                {
                                    cookies[urldecode(key)] = urldecode(value);
                                    seen_equal_sign = false;
                                    seen_key_start = false;
                                    key.clear();
                                    value.clear();
                                }
                                else
                                {
                                    value += line[pos];
                                }
                            }
                        }
                        if (key.size() > 0)
                        {
                            cookies[urldecode(key)] = urldecode(value);
                            key.clear();
                            value.clear();
                        }
                    }
                } // no ':' in it!
                read_with_limit(in, line);
            } // while (line != "\r")

            // If there is data being posted back to us as a query string then
            // pick out the queries using parse_url.
            if ((strings_equal_ignore_case(incoming.request_type, "POST") ||
                 strings_equal_ignore_case(incoming.request_type, "PUT")) &&
                strings_equal_ignore_case(left_substr(content_type,";"), "application/x-www-form-urlencoded"))
            {
                if (content_length > 0)
                {
                    incoming.body.resize(content_length);
                    in.read(&incoming.body[0],content_length);
                }
                parse_url(incoming.body, incoming.queries);
            }

            string::size_type pos = path.find_first_of("?");
            if (pos != string::npos)
            {
                parse_url(path.substr(pos+1), incoming.queries);
            }

            if (!in)
                throw http_parse_error("Error parsing HTTP request", 500);

            return content_length;
        }

    // ----------------------------------------------------------------------------------------

        void read_body (
            std::istream& in,
            incoming_things& incoming
        )
        {
            // if the body hasn't already been loaded and there is data to load
            if (incoming.body.size() == 0 &&
                incoming.headers.count("Content-Length") != 0)
            {
                const unsigned long content_length = string_cast<unsigned long>(incoming.headers["Content-Length"]);

                incoming.body.resize(content_length);
                if (content_length > 0)
                {
                    in.read(&incoming.body[0],content_length);
                }
            }
        }

    // ----------------------------------------------------------------------------------------

        void write_http_response (
            std::ostream& out,
            outgoing_things outgoing,
            const std::string& result
        )
        {
            using namespace http_impl;
            key_value_map& new_cookies      = outgoing.cookies;
            key_value_map_ci& response_headers = outgoing.headers;

            // only send this header if the user hasn't told us to send another kind
            bool has_content_type = false, has_location = false;
            for(key_value_map_ci::const_iterator ci = response_headers.begin(); ci != response_headers.end(); ++ci )
            {
                if ( !has_content_type && strings_equal_ignore_case(ci->first , "content-type") )
                {
                    has_content_type = true;
                }
                else if ( !has_location && strings_equal_ignore_case(ci->first , "location") )
                {
                    has_location = true;
                }
            }

            if ( has_location )
            {
                outgoing.http_return = 302;
            }

            if ( !has_content_type )
            {
                response_headers["Content-Type"] = "text/html";
            }

            response_headers["Content-Length"] = cast_to_string(result.size());

            out << "HTTP/1.0 " << outgoing.http_return << " " << outgoing.http_return_status << "\r\n";

            // Set any new headers
            for(key_value_map_ci::const_iterator ci = response_headers.begin(); ci != response_headers.end(); ++ci )
            {
                out << ci->first << ": " << ci->second << "\r\n";
            }

            // set any cookies
            for(key_value_map::const_iterator ci = new_cookies.begin(); ci != new_cookies.end(); ++ci )
            {
                out << "Set-Cookie: " << urlencode(ci->first) << '=' << urlencode(ci->second) << "\r\n";
            }
            out << "\r\n" << result;
        }

    // ----------------------------------------------------------------------------------------

        void write_http_response (
            std::ostream& out,
            const http_parse_error& e
        )
        {
            outgoing_things outgoing;
            outgoing.http_return = e.http_error_code;
            outgoing.http_return_status = e.what();
            write_http_response(out, outgoing, std::string("Error processing request: ") + e.what());
        }

    // ----------------------------------------------------------------------------------------

        void write_http_response (
            std::ostream& out,
            const std::exception& e
        )
        {
            outgoing_things outgoing;
            outgoing.http_return = 500;
            outgoing.http_return_status = e.what();
            write_http_response(out, outgoing, std::string("Error processing request: ") + e.what());
        }

    // ----------------------------------------------------------------------------------------

        const logger server_http::dlog("dlib.server_http");

    // ----------------------------------------------------------------------------------------

    }

    #endif // DLIB_SERVER_HTTP_CPp_