#include "http_server.hpp"

#include "encoding.hpp"

#include <algorithm>
#include <cctype>
#include <cstring>
#include <sstream>
#include <thread>

#ifdef _WIN32
#define NOMINMAX
#include <winsock2.h>
#include <ws2tcpip.h>
using Socket = SOCKET;
constexpr Socket kInvalidSocket = INVALID_SOCKET;
#else
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>
using Socket = int;
constexpr Socket kInvalidSocket = -1;
#endif

namespace connector {
namespace {

constexpr std::size_t kMaxBody = 200 * 1024 * 1024;
constexpr std::size_t kMaxHeaders = 64 * 1024;

void close_socket(Socket socket) {
#ifdef _WIN32
  closesocket(socket);
#else
  close(socket);
#endif
}

std::string lowercase(std::string value) {
  std::transform(value.begin(), value.end(), value.begin(), [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
  return value;
}

std::string status_text(int status) {
  switch (status) {
    case 200: return "OK";
    case 204: return "No Content";
    case 400: return "Bad Request";
    case 403: return "Forbidden";
    case 404: return "Not Found";
    case 413: return "Payload Too Large";
    case 500: return "Internal Server Error";
    case 503: return "Service Unavailable";
    default: return "Response";
  }
}

void send_all(Socket socket, const std::string& data) {
  std::size_t sent = 0;
  while (sent < data.size()) {
    const int count = send(socket, data.data() + sent, static_cast<int>((std::min)(data.size() - sent, static_cast<std::size_t>(1 << 20))), 0);
    if (count <= 0) return;
    sent += static_cast<std::size_t>(count);
  }
}

bool parse_request(Socket socket, HttpRequest& request, int& error_status) {
  std::string buffer;
  char chunk[8192];
  std::size_t header_end = std::string::npos;
  while ((header_end = buffer.find("\r\n\r\n")) == std::string::npos) {
    const int count = recv(socket, chunk, sizeof(chunk), 0);
    if (count <= 0) return false;
    buffer.append(chunk, count);
    if (buffer.size() > kMaxHeaders) { error_status = 413; return false; }
  }
  std::istringstream headers(buffer.substr(0, header_end));
  std::string line;
  if (!std::getline(headers, line)) return false;
  if (!line.empty() && line.back() == '\r') line.pop_back();
  std::istringstream first(line);
  std::string version;
  if (!(first >> request.method >> request.target >> version)) return false;
  while (std::getline(headers, line)) {
    if (!line.empty() && line.back() == '\r') line.pop_back();
    const auto separator = line.find(':');
    if (separator != std::string::npos) request.headers[lowercase(trim(line.substr(0, separator)))] = trim(line.substr(separator + 1));
  }
  const auto query_position = request.target.find('?');
  request.path = request.target.substr(0, query_position);
  if (query_position != std::string::npos) {
    const std::string query = request.target.substr(query_position + 1);
    std::size_t start = 0;
    while (start <= query.size()) {
      const auto end = query.find('&', start);
      const std::string part = query.substr(start, end - start);
      const auto equal = part.find('=');
      request.query[url_decode(part.substr(0, equal))] = url_decode(equal == std::string::npos ? "" : part.substr(equal + 1));
      if (end == std::string::npos) break;
      start = end + 1;
    }
  }
  std::size_t content_length = 0;
  if (const auto found = request.headers.find("content-length"); found != request.headers.end()) {
    try { content_length = static_cast<std::size_t>(std::stoull(found->second)); }
    catch (...) { error_status = 400; return false; }
  }
  if (content_length > kMaxBody) { error_status = 413; return false; }
  request.body = buffer.substr(header_end + 4);
  while (request.body.size() < content_length) {
    const int count = recv(socket, chunk, sizeof(chunk), 0);
    if (count <= 0) return false;
    request.body.append(chunk, count);
  }
  if (request.body.size() > content_length) request.body.resize(content_length);
  return true;
}

void serve_client(Socket client, const RequestHandler& handler) {
  HttpRequest request;
  int error_status = 400;
  HttpResponse response;
  if (parse_request(client, request, error_status)) {
    try { response = handler(request); }
    catch (const std::exception& error) {
      response.status = 500;
      response.headers["Content-Type"] = "application/json; charset=utf-8";
      response.body = std::string("{\"code\":\"INTERNAL_ERROR\",\"message\":\"") + error.what() + "\"}";
    }
  } else {
    response.status = error_status;
    response.body = "Bad request";
  }
  response.headers["Content-Length"] = std::to_string(response.body.size());
  response.headers["Connection"] = "close";
  std::ostringstream output;
  output << "HTTP/1.1 " << response.status << ' ' << status_text(response.status) << "\r\n";
  for (const auto& [name, value] : response.headers) output << name << ": " << value << "\r\n";
  output << "\r\n";
  send_all(client, output.str());
  send_all(client, response.body);
  close_socket(client);
}

}  // namespace

HttpServer::HttpServer() = default;
HttpServer::~HttpServer() { stop(); }

bool HttpServer::start(unsigned short port, RequestHandler handler, std::string& error) {
  if (running_) return true;
#ifdef _WIN32
  WSADATA data{};
  if (WSAStartup(MAKEWORD(2, 2), &data) != 0) { error = "无法初始化网络服务"; return false; }
#endif
  Socket server = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  if (server == kInvalidSocket) { error = "无法创建本地服务"; return false; }
  int reuse = 1;
  setsockopt(server, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<const char*>(&reuse), sizeof(reuse));
  sockaddr_in address{};
  address.sin_family = AF_INET;
  address.sin_port = htons(port);
  address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
  if (bind(server, reinterpret_cast<sockaddr*>(&address), sizeof(address)) != 0 || listen(server, 16) != 0) {
    close_socket(server);
    error = "端口 27843 已被占用，可能已有连接器正在运行";
    return false;
  }
  socket_ = static_cast<std::intptr_t>(server);
  handler_ = std::move(handler);
  running_ = true;
  thread_ = new std::thread([this] { accept_loop(); });
  return true;
}

void HttpServer::accept_loop() {
  const Socket server = static_cast<Socket>(socket_);
  while (running_) {
    Socket client = accept(server, nullptr, nullptr);
    if (client == kInvalidSocket) {
      if (running_) continue;
      break;
    }
    std::thread(serve_client, client, handler_).detach();
  }
}

void HttpServer::stop() {
  if (!running_.exchange(false)) return;
#ifdef _WIN32
  shutdown(static_cast<Socket>(socket_), SD_BOTH);
#else
  shutdown(static_cast<Socket>(socket_), SHUT_RDWR);
#endif
  close_socket(static_cast<Socket>(socket_));
  if (thread_) {
    auto* thread = static_cast<std::thread*>(thread_);
    if (thread->joinable()) thread->join();
    delete thread;
    thread_ = nullptr;
  }
#ifdef _WIN32
  WSACleanup();
#endif
}

}  // namespace connector