#include "server/request_handler.hpp"

#include "server/api_grammar.hpp"
#include "server/http/reply.hpp"
#include "server/http/request.hpp"

#include "util/json_renderer.hpp"
#include "util/simple_logger.hpp"
#include "util/string_util.hpp"
#include "util/typedefs.hpp"

#include "engine/route_parameters.hpp"
#include "util/json_container.hpp"
#include "osrm/osrm.hpp"

#include <boost/iostreams/filtering_streambuf.hpp>
#include <boost/iostreams/copy.hpp>
#include <boost/iostreams/filter/gzip.hpp>

#include <ctime>

#include <algorithm>
#include <iostream>
#include <string>

namespace osrm
{
namespace server
{

RequestHandler::RequestHandler() : routing_machine(nullptr) {}

void RequestHandler::handle_request(const http::request &current_request,
                                    http::reply &current_reply)
{
    util::json::Object json_result;

    // parse command
    try
    {
        std::string request_string;
        util::URIDecode(current_request.uri, request_string);

        // deactivated as GCC apparently does not implement that, not even in 4.9
        // std::time_t t = std::time(nullptr);
        // util::SimpleLogger().Write() << std::put_time(std::localtime(&t), "%m-%d-%Y %H:%M:%S") <<
        //     " " << current_request.endpoint.to_string() << " " <<
        //     current_request.referrer << ( 0 == current_request.referrer.length() ? "- " :" ") <<
        //     current_request.agent << ( 0 == current_request.agent.length() ? "- " :" ") <<
        //     request;

        time_t ltime;
        struct tm *time_stamp;

        ltime = time(nullptr);
        time_stamp = localtime(&ltime);

        // log timestamp
        util::SimpleLogger().Write()
            << (time_stamp->tm_mday < 10 ? "0" : "") << time_stamp->tm_mday << "-"
            << (time_stamp->tm_mon + 1 < 10 ? "0" : "") << (time_stamp->tm_mon + 1) << "-"
            << 1900 + time_stamp->tm_year << " " << (time_stamp->tm_hour < 10 ? "0" : "")
            << time_stamp->tm_hour << ":" << (time_stamp->tm_min < 10 ? "0" : "")
            << time_stamp->tm_min << ":" << (time_stamp->tm_sec < 10 ? "0" : "")
            << time_stamp->tm_sec << " " << current_request.endpoint.to_string() << " "
            << current_request.referrer << (0 == current_request.referrer.length() ? "- " : " ")
            << current_request.agent << (0 == current_request.agent.length() ? "- " : " ")
            << request_string;

        engine::RouteParameters route_parameters;
        APIGrammarParser api_parser(&route_parameters);

        auto api_iterator = request_string.begin();
        const bool result =
            boost::spirit::qi::parse(api_iterator, request_string.end(), api_parser);

        // check if the was an error with the request
        if (result && api_iterator == request_string.end())
        {
            // parsing done, lets call the right plugin to handle the request
            BOOST_ASSERT_MSG(routing_machine != nullptr, "pointer not init'ed");

            if (!route_parameters.jsonp_parameter.empty())
            { // prepend response with jsonp parameter
                const std::string json_p = (route_parameters.jsonp_parameter + "(");
                current_reply.content.insert(current_reply.content.end(), json_p.begin(),
                                             json_p.end());
            }

            const int return_code = routing_machine->RunQuery(route_parameters, json_result);
            json_result.values["status"] = return_code;
            // 4xx bad request return code
            if (return_code / 100 == 4)
            {
                current_reply.status = http::reply::bad_request;
                current_reply.content.clear();
                route_parameters.output_format.clear();
            }
            else
            {
                // 2xx valid request
                BOOST_ASSERT(return_code / 100 == 2);
            }
        }
        else
        {
            const auto position = std::distance(request_string.begin(), api_iterator);

            current_reply.status = http::reply::bad_request;
            json_result.values["status"] = http::reply::bad_request;
            json_result.values["status_message"] =
                "Query string malformed close to position " + std::to_string(position);
        }

        current_reply.headers.emplace_back("Access-Control-Allow-Origin", "*");
        current_reply.headers.emplace_back("Access-Control-Allow-Methods", "GET");
        current_reply.headers.emplace_back("Access-Control-Allow-Headers",
                                           "X-Requested-With, Content-Type");

        if (route_parameters.service == "tile" && json_result.values.find("pbf") != json_result.values.end())
        {
            std::copy(json_result.values["pbf"].get<osrm::util::json::Buffer>().value.cbegin(),
                      json_result.values["pbf"].get<osrm::util::json::Buffer>().value.cend(),
                      std::back_inserter(current_reply.content));

            current_reply.headers.emplace_back("Content-Type", "application/x-protobuf");
        }
        else if (route_parameters.jsonp_parameter.empty())
        { // json file
            util::json::render(current_reply.content, json_result);
            current_reply.headers.emplace_back("Content-Type", "application/json; charset=UTF-8");
            current_reply.headers.emplace_back("Content-Disposition",
                                               "inline; filename=\"response.json\"");
        }
        else
        { // jsonp
            util::json::render(current_reply.content, json_result);
            current_reply.headers.emplace_back("Content-Type", "text/javascript; charset=UTF-8");
            current_reply.headers.emplace_back("Content-Disposition",
                                               "inline; filename=\"response.js\"");
        }
        current_reply.headers.emplace_back("Content-Length",
                                           std::to_string(current_reply.content.size()));
        if (!route_parameters.jsonp_parameter.empty())
        { // append brace to jsonp response
            current_reply.content.push_back(')');
        }
    }
    catch (const std::exception &e)
    {
        current_reply = http::reply::stock_reply(http::reply::internal_server_error);
        util::SimpleLogger().Write(logWARNING) << "[server error] code: " << e.what()
                                               << ", uri: " << current_request.uri;
    }
}

void RequestHandler::RegisterRoutingMachine(OSRM *osrm) { routing_machine = osrm; }
}
}