/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2016 Ole Christian Eidheim
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <iostream>
#include <fstream>
#include <boost/filesystem.hpp>

#include "http-server/http_server.h"
#include "http_client_tcp.h"
#include "http_client_icn.h"

typedef icn_httpserver::HttpServer HttpServer;
typedef icn_httpserver::Response Response;
typedef icn_httpserver::Request Request;

namespace std {

void default_resource_send(const HttpServer &server,
                           shared_ptr<Response> response,
                           shared_ptr<ifstream> ifs,
                           shared_ptr<vector<char>> buffer,
                           std::size_t bytes_to_read) {
  streamsize read_length;

  if ((read_length = ifs->read(&(*buffer)[0], buffer->size()).gcount()) > 0) {
    response->write(&(*buffer)[0], read_length);

    if (bytes_to_read <= static_cast<streamsize>(buffer->size())) {
      // If this is the last part of the response, send it at the pointer deletion!
      return;
    }

    std::size_t to_read = bytes_to_read - read_length;
    server.send(response, [&server, response, ifs, buffer, to_read](const boost::system::error_code &ec) {
      if (!ec) {
        default_resource_send(server, response, ifs, buffer, to_read);
      } else {
        cerr << "Connection interrupted" << endl;
      }
    });
  }
}

void afterSignal(HttpServer *webServer, const boost::system::error_code &errorCode) {
  cout << "\nGracefully terminating http-server... wait." << endl;
  webServer->stop();
}

void usage(const char *programName) {
  cerr << programName << " [-p PATH_TO_ROOT_FOOT_FOLDER] [-o TCP_LISTEN_PORT] [-l WEBSERVER_PREFIX] [-x TCP_PROXY_ADDRESS] [-z ICN_PROXY_PREFIX]\n"
       << "Web server able to publish content and generate http responses over TCP/ICN\n" << endl;

  exit(1);
}

int main(int argc, char **argv) {
  // Parse command line arguments

  string root_folder = "/var/www/html";
  string webserver_prefix = "http://webserver";
  string tcp_proxy_address;
  string icn_proxy_prefix;
  int port = 8080;
  int opt = 0;

  while ((opt = getopt(argc, argv, "p:l:o:hx:z:")) != -1) {
    switch (opt) {
      case 'p':
        root_folder = optarg;
        break;
      case 'l':
        webserver_prefix = optarg;
        break;
      case 'x':
        tcp_proxy_address = optarg;
        break;
      case 'o':
        port = atoi(optarg);
        break;
      case 'z':
        icn_proxy_prefix = optarg;
        break;
      case 'h':
      default:
        usage(argv[0]);
        break;
    }
  }

  if (!boost::filesystem::exists(boost::filesystem::path(root_folder))) {

    // Try to create it
    try {
      if (!boost::filesystem::create_directories(boost::filesystem::path(root_folder))) {
        throw boost::filesystem::filesystem_error("", boost::system::error_code());
      }
    } catch (boost::filesystem::filesystem_error) {
      std::cerr << "The web root folder " << root_folder << " does not exist and its creation failed. Exiting.."
                << std::endl;
      return (EXIT_FAILURE);
    }
  }

  std::cout << "Using web root folder: [" << root_folder << "]" << std::endl;
  std::cout << "Using locator: [" << webserver_prefix << "]" << std::endl;
  if (!tcp_proxy_address.empty()) {
    std::cout << "Using TCP proxy: [" << tcp_proxy_address << "]" << std::endl;
  }
  if (!icn_proxy_prefix.empty()) {
    std::cout << "Using ICN proxy: [" << icn_proxy_prefix << "]" << std::endl;
  }

  boost::asio::io_service io_service;
  HttpServer server(port, webserver_prefix, 50, 5, 300, io_service);

  // GET for the path /info
  // Responds with some server info
  server.resource["^/info$"]["GET"] = [](shared_ptr<Response> response, shared_ptr<Request> request) {
    stringstream content_stream;
    content_stream << "<h1>This webserver is able to reply to HTTP over TCP/ICN</h1>";
    content_stream << request->getMethod() << " " << request->getPath() << " HTTP/" << request->getHttp_version()
                   << "<br>";

    for (auto &header: request->getHeader()) {
      content_stream << header.first << ": " << header.second << "<br>";
    }

    //find length of content_stream (length received using content_stream.tellp())
    content_stream.seekp(0, ios::end);

    *response << "HTTP/1.1 200 OK\r\nContent-Length: " << content_stream.tellp() << "\r\n\r\n"
              << content_stream.rdbuf();
  };

  // Default GET-example. If no other matches, this anonymous function will be called.
  // Will respond with content in the web/-directory, and its subdirectories.
  // Default file: index.html
  // Can for instance be used to retrieve an HTML 5 client that uses REST-resources on this server
  server.default_resource["GET"] = [&server, &root_folder, &tcp_proxy_address, &icn_proxy_prefix]
      (shared_ptr<Response> response, shared_ptr<Request> request) {
    const auto web_root_path = boost::filesystem::canonical(root_folder);

    boost::filesystem::path path = web_root_path;
    path /= request->getPath();

    auto socket_request = dynamic_cast<icn_httpserver::SocketRequest *>(request.get());

    std::chrono::milliseconds response_lifetime;

    if (path.extension().string() == ".mpd" || path.stem() == "latest") {
      std::cout << "Setting lifetime to 1 second" << std::endl;
      response_lifetime = std::chrono::milliseconds(1000);
    } else {
      std::cout << "Setting lifetime to 5 second" << std::endl;
      response_lifetime = std::chrono::milliseconds(5000);
    }

    response->setResponseLifetime(response_lifetime);

    if (boost::filesystem::exists(path)) {

      path = boost::filesystem::canonical(path);

      //Check if path is within web_root_path
      if (distance(web_root_path.begin(), web_root_path.end()) <= distance(path.begin(), path.end())
          && equal(web_root_path.begin(), web_root_path.end(), path.begin())) {

        if (boost::filesystem::is_directory(path)) {
          path /= "index.html";
        } // default path

        if (boost::filesystem::exists(path) && boost::filesystem::is_regular_file(path)) {

          auto ifs = make_shared<ifstream>();
          ifs->open(path.string(), ifstream::in | ios::binary);

          if (*ifs) {
            //read and send 15 MB at a time
            streamsize buffer_size = 15 * 1024 * 1024;
            auto buffer = make_shared<vector<char> >(buffer_size);

            ifs->seekg(0, ios::end);
            auto length = ifs->tellg();
            ifs->seekg(0, ios::beg);

            response->setResponseLength(length);
            *response << "HTTP/1.0 200 OK\r\nContent-Length: " << length << "\r\n\r\n";

            default_resource_send(server, response, ifs, buffer, length);

            return;

          }
        }
      }
    }

    string proxy;
    HTTPClient* client = nullptr;

    if (tcp_proxy_address.empty() && !icn_proxy_prefix.empty()) {
      proxy = icn_proxy_prefix;
      client = new HTTPClientIcn(20);
    } else if (!tcp_proxy_address.empty() && icn_proxy_prefix.empty()) {
      proxy = tcp_proxy_address;
      client = new HTTPClientTcp;
    } else if (!tcp_proxy_address.empty() && !icn_proxy_prefix.empty()) {
      if (socket_request) {
        proxy = icn_proxy_prefix;
        client = new HTTPClientIcn(20);
      } else {
        proxy = tcp_proxy_address;
        client = new HTTPClientTcp;
      }
    }

    if (!proxy.empty()) {
      // Fetch content from remote origin
      std::stringstream ss;

      if (strncmp("http://", proxy.c_str(), 7) != 0) {
        if (strncmp("https://", proxy.c_str(), 8) != 0) {
          ss << "https://";
        } else {
          ss << "http://";
        }
      }

      ss << proxy;
      ss << request->getPath();

      std::cout << "Forwarding request to " << ss.str() << std::endl;

      client->download(ss.str(), *response);

      delete client;

      if (response->size() == 0) {
        *response << "HTTP/1.1 504 Gateway Timeout\r\n\r\n";
      }

      return;
    }

    string content = "Could not open path " + request->getPath() + "\n";

    *response << "HTTP/1.1 404 Not found\r\nContent-Length: " << content.length() << "\r\n\r\n" << content;

  };

  // Let the main thread to catch SIGINT and SIGQUIT
  boost::asio::signal_set signals(io_service, SIGINT, SIGQUIT);
  signals.async_wait(bind(afterSignal, &server, placeholders::_1));

  thread server_thread([&server]() {
    //Start server
    server.start();
  });

  server_thread.join();

  return 0;
}

} // end namespace std


int main(int argc, char **argv) {
  return std::main(argc, argv);
}