#include "Global.h"
#include "Performance_Monitor.h"

#include <algorithm>
#include <cctype>
#include <string_view>

namespace {
  constexpr std::size_t kMaxLogRequestBodySize = 8 * 1024;

  void Log_Request_Body_If_Small(const drogon::HttpRequestPtr &request) {
    const auto &body = request->getBody();
    if (body.empty()) {
      return;
    }

    if (body.size() <= kMaxLogRequestBodySize) {
      LOG_INFO << "[request body] "
             << "path=" << request->path() << ", size=" << body.size()
             << ", body=" << std::string(body.data(), body.size());
    } else {
      LOG_INFO << "[request body skipped] "
             << "path=" << request->path() << ", size=" << body.size()
             << ", max=" << kMaxLogRequestBodySize;
    }
  }

  bool Is_Invalid_Http_Param(const std::exception &e) {
    return dynamic_cast<const Invalid_Http_Param *>(&e) != nullptr ||
           dynamic_cast<const Psc::json_assign_error *>(&e) != nullptr ||
           dynamic_cast<const std::invalid_argument *>(&e) != nullptr;
  }

  bool Is_Safe_Version_Directory_Name(std::string_view name) {
    if (name.empty() || name == "." || name == "..") {
      return false;
    }
    return std::ranges::all_of(name, [](unsigned char ch) {
      return std::isalnum(ch) != 0 || ch == '.' || ch == '_' || ch == '-';
    });
  }

  bool Is_Safe_Archive_Extension(std::string_view extension) {
    if (extension.empty() || extension.front() == '.' ||
        extension.back() == '.') {
      return false;
    }
    return std::ranges::all_of(extension, [](unsigned char ch) {
      return std::isalnum(ch) != 0 || ch == '.' || ch == '_' || ch == '-';
    });
  }

  std::string Normalize_Archive_Extension(std::string_view extension,
                                          std::string_view fallback = "zip") {
    auto normalized = std::string(extension);
    while (!normalized.empty() && normalized.front() == '.') {
      normalized.erase(normalized.begin());
    }
    if (normalized.empty()) {
      normalized = std::string(fallback);
    }
    if (!Is_Safe_Archive_Extension(normalized)) {
      throw std::invalid_argument("invalid archive extension: " + normalized);
    }
    return normalized;
  }

  std::optional<std::string> Try_Get_String_Field(const JSON &object,
                                                  std::string_view key) {
    const JSON *value = object.get(key);
    if (value == nullptr) {
      return std::nullopt;
    }
    if (value->valueType != Psc::String) {
      throw std::invalid_argument(std::string(key) + " must be a string");
    }
    return value->val;
  }

  struct Archive_Export_Request {
    std::string version;
    Archive_Write_Options archive;
  };

  Archive_Export_Request
  Parse_Archive_Export_Request(const drogon::HttpRequestPtr &req,
                               std::string_view default_version) {
    Archive_Export_Request result;
    result.version = std::move(default_version);

    const auto &body = req->getBody();
    if (body.empty()) {
      return result;
    }

    auto parsed = Psc::try_parse_json(body.data());
    if (!parsed.has_value()) {
      throw_invalid_http_param("request body is not valid JSON");
    }

    const JSON &params = parsed.value();
    if (auto version = Try_Get_String_Field(params, "version")) {
      if (!version->empty()) {
        result.version = *version;
      }
    }
    if (!Is_Safe_Version_Directory_Name(result.version)) {
      throw std::invalid_argument("invalid version name: " + result.version);
    }

    if (auto format = Try_Get_String_Field(params, "format")) {
      if (!format->empty()) {
        result.archive.format = *format;
      }
    }
    if (auto filter = Try_Get_String_Field(params, "filter")) {
      result.archive.filter = *filter;
    }
    if (auto extension = Try_Get_String_Field(params, "extension")) {
      if (!extension->empty()) {
        result.archive.extension = Normalize_Archive_Extension(*extension);
      }
    } else {
      result.archive.extension =
          Normalize_Archive_Extension(result.archive.extension);
    }

    return result;
  }

  const Archive_Layout_Rules &Upgrade_Zip_Layout_Rules() {
    static const Archive_Layout_Rules rules = [] {
      Archive_Layout_Rules value;
      value.directories = {
        {
          "",
          {"adsb_cfg.ini", "config.json", "ecap_server", "lib9002config.json"},
          {"lib9002", "wwwroot"},
          {},
          {}
        },
        {"lib9002", {"lib9002.so", "testserver"}, {"env"}, {}, {}}
      };
      return value;
    }();
    return rules;
  }
} // namespace

void setupCors();

void Global::init_web_server() {
  register_http_performance_monitor(
    http_monitor_config.access_log,
    http_monitor_config.slow_request_threshold_ms);
  setupCors();
  static auto &web_server = web_server_config;
  Web_Server &svr = this->svr;
  auto &da = drogon::app();
  auto return_file = [](std::string_view path) {
    auto res = drogon::HttpResponse::newHttpResponse();
    if (std::filesystem::exists(path)) {
      std::string content;
      httplib::detail::read_file(path, content);
      auto content_type = httplib::detail::find_content_type(
        path, {}, "application/octet-stream");
      res->setContentTypeString(content_type);
      res->setBody(content);
      // res.set_file_content(path);
    } else {
      res->setStatusCode(drogon::k404NotFound);
      JSON ret = JSON::object();
      ret.append({"LOG_POS", LOG_POS});
      ret.append({"not_found_path", path});
      res->setContentTypeCode(drogon::CT_TEXT_PLAIN);
      res->setBody(ret.to_json_string());
    }
    return res;
  };
  auto add_path = [return_file](std::string_view path) {
    drogon::app().registerHandlerViaRegex(
      std::string(path),
      [return_file](
    const drogon::HttpRequestPtr &req,
    std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
        callback(return_file(web_server.get_true_webapp() + "/index.html"));
      },
      {drogon::Get});
  };

  drogon::app().registerHandlerViaRegex(
    R"(^/tiles/.*$)",
    [return_file](
  const drogon::HttpRequestPtr &req,
  std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
      auto path = web_server.get_true_tiles() + req->getPath().substr(6);
      callback(return_file(path));
    },
    {drogon::Get});

  drogon::app().registerHandlerViaRegex(
    "/",
    [return_file](
  const drogon::HttpRequestPtr &req,
  std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
      callback(return_file(web_server.get_true_webapp() + "/index.html"));
    },
    {drogon::Get});

  add_path(R"(^/settings)");
  add_path(R"(^/map)");
  add_path(R"(^/dsp)");
  add_path(R"(^/aircraftlist)");
  drogon::app().registerHandlerViaRegex(
    R"(^/ui(/.*)?$)",
    [return_file](
  const drogon::HttpRequestPtr &req,
  std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
      std::cout << req->path() << std::endl;
      auto res = drogon::HttpResponse::newHttpResponse();
      auto path = web_server.get_true_webapp();
      auto rp = "/" + req->path().substr(3);
      if (rp == "/") {
        path += "/index.html";
      } else {
        path += rp;
      }
      callback(return_file(path));
    });

  State_Report::instance();
  svr.Get(R"(/get_debug_info)", [](HTTP_Param) {
    JSON arr = JSON::array();
    auto &sp = Global::instance()->mode_acs.data_feed_config.pool_;
    arr.append(JSON::object(
      {{"remain_size", sp.remain_size()}, {"free_size", sp.free_size()}}));
    res->setBody(arr.to_json_string("", "\n", ""));
  });

  mlat.server(this);
  database_server(this);
  external_resources_manager.server(this);
  device_config.server(this);
  mode_acs.server(this);
  dsp_config.server(this);


  // s.w.init();

  drogon::app().registerHandler(
    api + "export_logs",
    [](const drogon::HttpRequestPtr &req,
       std::function<void(const drogon::HttpResponsePtr &)> &&cb) {
      try {
        auto export_request =
            Parse_Archive_Export_Request(req, Global::instance()->version);
        std::string name = export_request.version;
        auto version_dir = std::filesystem::path(get_exe_dir() + "/..");
        std::string data = archive_directory_to_memory(
          version_dir / name / "logs", {}, export_request.archive);
        auto resp = drogon::HttpResponse::newHttpResponse();
        resp->setBody(data);
        resp->setContentTypeString("application/octet-stream");
        resp->addHeader("Content-Disposition",
                        "attachment; filename*=UTF-8''" + name + "_logs." +
                        std::string(export_request.archive.extension));
        resp->addHeader("ok", "true");
        cb(resp);
      } catch (const std::exception &e) {
        auto resp = drogon::HttpResponse::newHttpResponse();
        resp->addHeader("ok", "false");
        Psc::JSON json =
            JSON::object({{"message", Psc::platform_2_utf8(e.what())}});
        resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
        resp->setBody(json.to_json_string());
        cb(resp);
      }
    });

  drogon::app().registerHandler(
    api + "export_version",
    [](const drogon::HttpRequestPtr &req,
       std::function<void(const drogon::HttpResponsePtr &)> &&cb) {
      try {
        auto export_request =
            Parse_Archive_Export_Request(req, Global::instance()->version);
        std::string name = export_request.version;
        auto version_dir = std::filesystem::path(get_exe_dir() + "/..");

        std::cout << "准备压缩:" << std::endl;
        std::string data = archive_directory_to_memory(
          version_dir / name,
          {
            "logs/", "uploads/", "drogon_uploads/",
            "backups/", // ghw的什么文件路径
            "stack_trace.txt", "pt.log", "ecap_server.log", "Core", "core",
            name + ".zip", name + "." + std::string(export_request.archive.extension)
          },
          export_request.archive);
        std::cout << "压缩成功:" << data.size() << std::endl;
        auto resp = drogon::HttpResponse::newHttpResponse();
        resp->setBody(data);
        resp->setContentTypeString("application/octet-stream");
        resp->addHeader("Content-Disposition",
                        "attachment; filename*=UTF-8''" + name + "." +
                        std::string(export_request.archive.extension));
        resp->addHeader("ok", "true");
        cb(resp);
      } catch (const std::exception &e) {
        auto message = Psc::platform_2_utf8(e.what());
        std::cout << "导出异常触发:" << message << "   " << LOG_POS
            << std::endl;
        auto resp = drogon::HttpResponse::newHttpResponse();

        Psc::JSON json = JSON::object({{"message", message}});
        resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
        resp->setBody(json.to_json_string());
        resp->addHeader("ok", "false");
        cb(resp);
      }
    });

  drogon::app().registerHandler(api + "restart_device", [](const drogon::
                                                           HttpRequestPtr
                                                           &req,
                                                           std::function<void(
                                                             const drogon::
                                                             HttpResponsePtr
                                                             &)>
                                                           &&cb) {
#ifdef __linux__
    std::string root_dir = Psc::get_exe_dir() + "/..";

    std::string log_file = fmt::format("{}/restart_device.log", root_dir);
    std::string cmd = fmt::format(
      R"(systemd-run --scope --slice=system.slice sudo bash "{}/restart_device.bash" > {} 2>&1 &)",
      root_dir, log_file);
    std::cout << "Generated Command: " << cmd << std::endl;
    std::system(cmd.c_str());
#endif
    auto resp = drogon::HttpResponse::newHttpResponse();
    resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
    resp->setBody(R"({"ok":true})");
    cb(resp);
  });

  drogon::app().registerHandler(
    api + "import_version",
    [](const drogon::HttpRequestPtr &req,
       std::function<void(const drogon::HttpResponsePtr &)> &&cb) {
      try {
        // ---------- 参数校验 ----------
        auto dir = req->getHeader("dir");
        if (!Is_Safe_Version_Directory_Name(dir)) {
          throw std::invalid_argument("invalid or missing header: dir");
        }

        const auto &body = req->getBody();
        auto archive_layout_result = validate_archive_layout_from_memory(
          body.data(), body.size(), Upgrade_Zip_Layout_Rules());
        if (!archive_layout_result) {
          throw Invalid_Archive_Error(archive_layout_result.error());
        }

        auto version_dir = std::filesystem::path(get_exe_dir() + "/..");
        // ---------- 路径准备 ----------
        auto targetDir = version_dir / dir;

        std::cout << "========dir====" << dir << std::endl;
        std::cout << "========version_dir====" << version_dir << std::endl;
        std::cout << "========targetDir====" << targetDir << std::endl;

        std::filesystem::create_directories(targetDir);

        const auto archive_extension =
            Normalize_Archive_Extension(req->getHeader("archive-extension"));
        auto archivePath = targetDir / (dir + "." + archive_extension);

        // ---------- 写 zip ----------
        std::ofstream ofs(archivePath, std::ios::binary);
        if (!ofs) {
          throw std::runtime_error("open archive failed: " +
                                   archivePath.string());
        }

        ofs.write(body.data(), body.size());
        if (!ofs) {
          throw std::runtime_error("write archive failed: " +
                                   archivePath.string());
        }
        ofs.close();
        if (!ofs) {
          throw std::runtime_error("close archive failed: " +
                                   archivePath.string());
        }

#ifdef _WIN32
        std::string root_dir = version_dir.string();
        std::string old_version =
            Global::instance()->version; // Global version info
        std::string new_version = dir;
        std::string log_file = fmt::format(
          "{}/upgrade_{}_to_{}.log", root_dir, old_version, new_version);
        std::string cmd = fmt::format(
          R"(powershell -NoProfile -ExecutionPolicy Bypass -Command "& {{ . '{}/upgrade.legacy' '{}' '{}' > '{}' 2>&1 }}" )",
          root_dir, old_version, new_version, log_file);
#else
        std::string root_dir = version_dir.string();
        std::string old_version =
            Global::instance()->version; // Global version info
        std::string new_version = dir;
        std::string log_file = fmt::format(
          "{}/upgrade_{}_to_{}.log", root_dir, old_version, new_version);
        std::string cmd = fmt::format(
          R"(systemd-run --scope --slice=system.slice sudo bash "{}/upgrade.bash" "{}" "{}" > {} 2>&1 &)",
          root_dir, old_version, new_version, log_file);
#endif
        std::cout << "Generated Command: " << cmd << std::endl;
        std::system(cmd.c_str());
        // ---------- 成功响应 ----------
        auto resp = drogon::HttpResponse::newHttpResponse();
        resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
        resp->setBody(R"({"ok":true})");
        cb(resp);
      } catch (const std::exception &e) {
        auto resp = drogon::HttpResponse::newHttpResponse();
        const bool invalid_input =
            dynamic_cast<const Invalid_Archive_Error *>(&e) != nullptr ||
            dynamic_cast<const std::invalid_argument *>(&e) != nullptr;
        resp->setStatusCode(invalid_input
                              ? drogon::k400BadRequest
                              : drogon::k500InternalServerError);
        resp->setContentTypeCode(drogon::CT_APPLICATION_JSON);
        auto reason = Psc::platform_2_utf8(e.what());
        std::cout << "异常" << reason << std::endl;
        Psc::JSON json = JSON::object({{"ok", false}, {"error", reason}});
        resp->setBody(json.to_json_string());
        cb(resp);
      }
    },
    {drogon::Post});

  svr.Post(api + "get_debug_log", [](HTTP_Param) {
    CHECK_JSON_PARAM
    HTTP_REQUIRE_VALUE(
      start_serial_number,
      params.try_get_number<Serial_Number_Type>("serial_number"))
    auto log =
        base64_encode(debug_logger_info_manager.get_info(start_serial_number));
    JSON ret = JSON::object();
    ret.append({"log", log});
    ret.append(
      {"serial_number", debug_logger_info_manager.get_cur_serial_number()});
    ret.append({"start_serial_number", start_serial_number});
    res->setBody(warp(ret).to_json_string());
  });

  svr.Post(api + "get_general_info", [](HTTP_Param) {
    auto g = Global::instance();
    // auto &db = *Global::instance()->total_source();
    auto ret = JSON::object();
    // ret.append({"total_source key", db.key});
    // ret.append({"飞机总数", db.get_aircraft_num()});
    // ret.append({"解出位置的数量", db.have_pos_aircraft_num});
    JSON arr = JSON::object();
    for (auto &ds: g->mode_acs.data_source_config.map.list()) {
      if (!ds->enable)
        continue;
      arr.append({ds->key, ds->statistic_json()});
    }
    ret.append({"统计信息", arr});
    // ret.append({"基站信息", base_station.to_Json()});
    res->setBody(warp(ret).to_json_string());
  });

  svr.Post(api + "version", [this](HTTP_Param) {
    auto ret = JSON::object();
    ret.append({"version", version});
    res->setBody(warp(ret).to_json_string());
  });

  auto now = std::chrono::system_clock::now();
  start_server_time = std::chrono::system_clock::to_time_t(now);
  svr.Post(api + "start_device_time", [this](HTTP_Param) {
    auto ret = JSON::object();
    ret.append({"start_device_time", start_server_time});
    res->setBody(warp(ret).to_json_string());
  });

  da.setDefaultHandler(
    [](const drogon::HttpRequestPtr &req,
       std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
      LOG_WARN << "[http route not found] "
          << "path=" << req->path();

      auto res = drogon::HttpResponse::newHttpResponse();

      res->setStatusCode(drogon::k404NotFound);
      res->setBody("not found");
      res->addHeader("Content-Type", "text/plain; charset=utf-8");

      callback(res);
    });

  da.setCustomErrorHandler(
    [](drogon::HttpStatusCode status,
       const drogon::HttpRequestPtr &req) -> drogon::HttpResponsePtr {
      LOG_WARN << "[http error] "
          << "path=" << req->path()
          << ", status=" << static_cast<int>(status);

      auto res = drogon::HttpResponse::newHttpResponse();

      res->setStatusCode(status);
      res->setBody("http error");
      res->addHeader("Content-Type", "text/plain; charset=utf-8");

      return res;
    });

  da.setExceptionHandler(
    [](const std::exception &e, const drogon::HttpRequestPtr &req,
       std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
      auto res = drogon::HttpResponse::newHttpResponse();

      if (Is_Invalid_Http_Param(e)) {
        LOG_WARN << "[invalid http parameters] "
            << "path=" << req->path() << ", detail=" << e.what();
        Log_Request_Body_If_Small(req);

        res->setStatusCode(drogon::k400BadRequest);
        res->setContentTypeCode(drogon::CT_APPLICATION_JSON);
        res->setBody(R"({"code":400,"message":"invalid http parameters"})");
      } else {
        LOG_ERROR << "[handler exception] "
            << "path=" << req->path() << ", what=" << e.what();

        res->setStatusCode(drogon::k500InternalServerError);
        res->setContentTypeCode(drogon::CT_APPLICATION_JSON);
        res->setBody(R"({"code":500,"message":"internal server error"})");
      }

      callback(res);
    });

  da.setUploadPath(get_exe_dir() + "/drogon_uploads");
  std::cout << "上传路径: " << da.getUploadPath() << std::endl;

  init_ok = true;
}

void setupCors() {
  // Register sync advice to handle CORS preflight (OPTIONS) requests
  drogon::app().registerSyncAdvice(
    [](const drogon::HttpRequestPtr &req) -> drogon::HttpResponsePtr {
      if (req->method() == drogon::HttpMethod::Options) {
        auto resp = drogon::HttpResponse::newHttpResponse();

        // Set Access-Control-Allow-Origin header based on the Origin
        // request header
        const auto &origin = req->getHeader("Origin");
        if (!origin.empty()) {
          resp->addHeader("Access-Control-Allow-Origin", origin);
        }

        // Set Access-Control-Allow-Methods based on the requested method
        const auto &requestMethod =
            req->getHeader("Access-Control-Request-Method");
        if (!requestMethod.empty()) {
          resp->addHeader("Access-Control-Allow-Methods", requestMethod);
        }

        // Allow credentials to be included in cross-origin requests
        resp->addHeader("Access-Control-Allow-Credentials", "true");

        // Set allowed headers from the Access-Control-Request-Headers
        // header
        const auto &requestHeaders =
            req->getHeader("Access-Control-Request-Headers");
        if (!requestHeaders.empty()) {
          resp->addHeader("Access-Control-Allow-Headers", requestHeaders);
        }

        return std::move(resp);
      }
      return {};
    });

  // Register post-handling advice to add CORS headers to all responses
  drogon::app().registerPostHandlingAdvice(
    [](const drogon::HttpRequestPtr &req,
       const drogon::HttpResponsePtr &resp) -> void {
      // Set Access-Control-Allow-Origin based on the Origin request
      // header
      const auto &origin = req->getHeader("Origin");
      if (!origin.empty()) {
        resp->addHeader("Access-Control-Allow-Origin", origin);
      }

      // Reflect the requested Access-Control-Request-Method back in the
      // response
      const auto &requestMethod =
          req->getHeader("Access-Control-Request-Method");
      if (!requestMethod.empty()) {
        resp->addHeader("Access-Control-Allow-Methods", requestMethod);
      }

      // Allow credentials to be included in cross-origin requests
      resp->addHeader("Access-Control-Allow-Credentials", "true");

      // Reflect the requested Access-Control-Request-Headers back
      const auto &requestHeaders =
          req->getHeader("Access-Control-Request-Headers");
      if (!requestHeaders.empty()) {
        resp->addHeader("Access-Control-Allow-Headers", requestHeaders);
      }
    });
}