#include "HttpServer.hpp"
#include <boost/log/trivial.hpp>
#include <condition_variable>
#include "GUI_App.hpp"
#include "slic3r/Utils/Http.hpp"
#include "slic3r/Utils/NetworkAgent.hpp"
#include  "sentry_wrapper/SentryWrapper.hpp"
#ifdef _WIN32
#include <windows.h>
#include <io.h>
#endif

namespace Slic3r { namespace GUI {

// 检测Windows系统是否支持UTF-8模式
bool is_windows_utf8_mode()
{
#ifdef _WIN32
    static bool checked = false;
    static bool utf8_mode = false;
    
    if (!checked) {
        // 检查系统是否启用了UTF-8模式
        // 最可靠的方法：检查ANSI代码页是否为UTF-8
        if (GetACP() == CP_UTF8) {
            utf8_mode = true;
        } else {
            // 对于现代Windows系统（Windows 10 1903+），
            // 即使没有全局启用UTF-8模式，文件系统API通常也能处理UTF-8路径
            // 这里我们采用保守策略：只有在明确启用UTF-8模式时才返回true
            utf8_mode = false;
        }
        checked = true;
    }
    
    return utf8_mode;
#else
    return true; // 非Windows系统通常支持UTF-8
#endif
}

// 辅助函数：将UTF-8字符串转换为适合文件系统操作的编码
std::string utf8_to_filesystem_encoding(const std::string& utf8_str)
{
#ifdef _WIN32
    if (utf8_str.empty()) return utf8_str;
    
    // 策略1：如果系统明确支持UTF-8模式，直接返回UTF-8字符串
    if (is_windows_utf8_mode()) {
        return utf8_str;
    }
    
    // 策略2：传统模式需要转换为系统编码（GBK）
    // 虽然某些情况下UTF-8路径可能成功，但为了确保兼容性，还是进行编码转换
    // 将UTF-8转换为宽字符（UTF-16）
    int wlen = MultiByteToWideChar(CP_UTF8, 0, utf8_str.c_str(), -1, nullptr, 0);
    if (wlen <= 0) return utf8_str; // 转换失败，返回原字符串
    
    std::wstring wstr(wlen - 1, 0);
    MultiByteToWideChar(CP_UTF8, 0, utf8_str.c_str(), -1, &wstr[0], wlen);
    
    // 将宽字符转换为系统编码（GBK）
    int len = WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), -1, nullptr, 0, nullptr, nullptr);
    if (len <= 0) return utf8_str; // 转换失败，返回原字符串
    
    std::string result(len - 1, 0);
    WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), -1, &result[0], len, nullptr, nullptr);
    
    return result;
#else
    // 在非Windows系统上，UTF-8通常就是系统编码
    return utf8_str;
#endif
}

std::string url_get_param(const std::string& url, const std::string& key)
{
    size_t start = url.find(key);
    if (start == std::string::npos)
        return "";
    size_t eq = url.find('=', start);
    if (eq == std::string::npos)
        return "";
    std::string key_str = url.substr(start, eq - start);
    if (key_str != key)
        return "";
    start += key.size() + 1;
    size_t end = url.find('&', start);
    if (end == std::string::npos)
        end = url.length(); // Last param
    std::string result = url.substr(start, end - start);
    return result;
}

void session::start() { read_first_line(); }

void session::stop()
{
    boost::system::error_code ignored_ec;
    socket.shutdown(boost::asio::socket_base::shutdown_both, ignored_ec);
    socket.close(ignored_ec);
}

void session::read_first_line()
{
    auto self(shared_from_this());

    async_read_until(socket, buff, '\r', [this, self](const boost::beast::error_code& e, std::size_t s) {
        if (!e) {
            std::string  line, ignore;
            std::istream stream{&buff};
            std::getline(stream, line, '\r');
            std::getline(stream, ignore, '\n');
            headers.on_read_request_line(line);
            read_next_line();
        } else if (e != boost::asio::error::operation_aborted) {
            server.stop(self);
        }
    });
}

void session::read_body()
{
    auto self(shared_from_this());

    int                                nbuffer = 1000;
    std::shared_ptr<std::vector<char>> bufptr  = std::make_shared<std::vector<char>>(nbuffer);
    async_read(socket, boost::asio::buffer(*bufptr, nbuffer),
               [this, self](const boost::beast::error_code& e, std::size_t s) { server.stop(self); });
}

void session::read_next_line()
{
    auto self(shared_from_this());

    if (headers.method == "OPTIONS") {
        // 构造OPTIONS响应（允许跨域）
        std::stringstream ssOut;
        ssOut << "HTTP/1.1 200 OK\r\n";
        ssOut << "Access-Control-Allow-Origin: *\r\n";                            // 允许所有源
        ssOut << "Access-Control-Allow-Methods: GET, POST, OPTIONS\r\n";          // 允许的方法
        ssOut << "Access-Control-Allow-Headers: Content-Type, Authorization\r\n"; // 允许的请求头
        ssOut << "Content-Length: 0\r\n";                                         // 无响应体
        ssOut << "\r\n";                                                          // 头和主体之间的空行（必须）

        // 异步发送响应
        async_write(socket, boost::asio::buffer(ssOut.str()), [this, self](const boost::beast::error_code& e, std::size_t s) {
            std::cout << "OPTIONS预检请求已处理" << std::endl;
            server.stop(self); // 关闭连接
        });
        return; // 提前返回，避免后续逻辑
    }

    async_read_until(socket, buff, '\r', [this, self](const boost::beast::error_code& e, std::size_t s) {
        if (!e) {
            std::string  line, ignore;
            std::istream stream{&buff};
            std::getline(stream, line, '\r');
            std::getline(stream, ignore, '\n');
            headers.on_read_header(line);

            if (line.length() == 0) {
                if (headers.content_length() == 0) {
                    std::cout << "Request received: " << headers.method << " " << headers.get_url();
                    if (headers.method == "OPTIONS") {
                        // Ignore http OPTIONS
                        server.stop(self);
                        return;
                    }

                    const std::string url_str = Http::url_decode(headers.get_url());
                    const auto        resp    = server.server.m_request_handler(url_str);
                    std::stringstream ssOut;
                    resp->write_response(ssOut);
                    std::shared_ptr<std::string> str = std::make_shared<std::string>(ssOut.str());
                    async_write(socket, boost::asio::buffer(str->c_str(), str->length()),
                                [this, self, str](const boost::beast::error_code& e, std::size_t s) {
                                    std::cout << "done" << std::endl;
                                    server.stop(self);
                                });
                } else {
                    read_body();
                }
            } else {
                read_next_line();
            }
        } else if (e != boost::asio::error::operation_aborted) {
            server.stop(self);
        }
    });
}

void HttpServer::IOServer::do_accept()
{
    acceptor.async_accept([this](boost::system::error_code ec, boost::asio::ip::tcp::socket socket) {
        if (!acceptor.is_open()) {
            return;
        }

        if (!ec) {
            const auto ss = std::make_shared<session>(*this, std::move(socket));
            start(ss);
        }

        do_accept();
    });
}

void HttpServer::IOServer::start(std::shared_ptr<session> session)
{
    sessions.insert(session);
    session->start();
}

void HttpServer::IOServer::stop(std::shared_ptr<session> session)
{
    sessions.erase(session);
    session->stop();
}

void HttpServer::IOServer::stop_all()
{
    for (auto s : sessions) {
        s->stop();
    }
    sessions.clear();
}

HttpServer::IOServer::IOServer(HttpServer& server) : server(server), acceptor(io_service)
{
    boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), server.port);
    acceptor.open(endpoint.protocol());
    acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
    acceptor.bind(endpoint);
}

HttpServer::HttpServer(boost::asio::ip::port_type port) : port(port) {}

HttpServer::~HttpServer()
{
    BOOST_LOG_TRIVIAL(debug) << "HttpServer destructor called, cleaning up resources...";
    stop();
    BOOST_LOG_TRIVIAL(debug) << "HttpServer destructor completed";
}

bool HttpServer::is_port_available(boost::asio::ip::port_type port)
{
    try {
        boost::asio::io_service        io_service;
        boost::asio::ip::tcp::acceptor acceptor(io_service);
        boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), port);

        acceptor.open(endpoint.protocol());
        acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
        acceptor.bind(endpoint);
        acceptor.close();
        return true;
    } catch (const boost::system::system_error&) {
        return false;
    }
}

boost::asio::ip::port_type HttpServer::find_available_port(boost::asio::ip::port_type start_port)
{
    // 尝试从起始端口开始查找可用端口
    for (boost::asio::ip::port_type p = start_port; p < start_port + 1000; ++p) {
        if (is_port_available(p)) {
            return p;
        }
    }
    throw std::runtime_error("No available ports found");
}

void HttpServer::start()
{
    BOOST_LOG_TRIVIAL(info) << "start_http_service...";

    try {
        // 如果指定端口不可用，查找下一个可用端口
        if (!is_port_available(port)) {
            auto new_port = find_available_port(port + 1);
            BOOST_LOG_TRIVIAL(info) << "Original port " << port << " is in use, switching to port " << new_port;
            port = new_port;
        }

        start_http_server    = true;
        m_http_server_thread = create_thread([this] {
            try {
                set_current_thread_name("http_server");
                server_ = std::make_unique<IOServer>(*this);
                server_->acceptor.listen();
                server_->do_accept();
                server_->io_service.run();
            } catch (const std::exception& e) {
                BOOST_LOG_TRIVIAL(error) << "HTTP server error: " << e.what();
                Slic3r::sentryReportLog(Slic3r::SENTRY_LOG_FATAL,std::string("HttpServer::start ") + e.what(), BP_LOCAL_SERVER);
                start_http_server = false;
            }
        });

        // 等待服务器启动
        std::this_thread::sleep_for(std::chrono::milliseconds(100));

        if (!start_http_server) {
            throw std::runtime_error("Failed to start HTTP server");
        }

        BOOST_LOG_TRIVIAL(info) << "HTTP server started successfully on port " << port;
        
        // 启动健康检查
        BOOST_LOG_TRIVIAL(debug) << "Starting health check for HTTP server...";
        start_health_check();
        
        // 重启检查已集成到健康检查中，无需单独线程
        
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << "Failed to start HTTP server: " << e.what();
        std::string error_msg = "Failed to start HTTP server on port " + std::to_string(port) + ": " + e.what();
        Slic3r::sentryReportLog(Slic3r::SENTRY_LOG_FATAL, error_msg.c_str(), BP_LOCAL_SERVER);
        start_http_server = false;
        throw;
    }
}

void HttpServer::stop()
{
    start_http_server = false;
    
    // 停止健康检查
    stop_health_check();
    
    // 重启检查已集成到健康检查中，无需单独停止
    
    if (server_) {
        server_->acceptor.close();
        server_->stop_all();
        server_->io_service.stop();
    }
    if (m_http_server_thread.joinable())
        m_http_server_thread.join();
    server_.reset();
}

void HttpServer::restart()
{
    BOOST_LOG_TRIVIAL(info) << "Restarting HTTP server on port " << port << "...";
    
    BOOST_LOG_TRIVIAL(debug) << "Stopping current HTTP server...";
    // 只停止HTTP服务器，不停止健康检查和重启检查线程
    start_http_server = false;
    
    if (server_) {
        server_->acceptor.close();
        server_->stop_all();
        server_->io_service.stop();
    }
    if (m_http_server_thread.joinable())
        m_http_server_thread.join();
    server_.reset();
    
    BOOST_LOG_TRIVIAL(debug) << "Waiting for resources to be released...";
    std::this_thread::sleep_for(std::chrono::milliseconds(500)); // 等待资源释放
    
    BOOST_LOG_TRIVIAL(debug) << "Starting new HTTP server...";
    start();
    
    BOOST_LOG_TRIVIAL(info) << "HTTP server restart completed";
}

bool HttpServer::is_healthy()
{
    if (!start_http_server || !server_) {
        BOOST_LOG_TRIVIAL(debug) << "Health check failed: server not started or server object is null";
        return false;
    }
    
    try {
        // 检查acceptor是否正常打开
        if (!server_->acceptor.is_open()) {
            BOOST_LOG_TRIVIAL(debug) << "Health check failed: acceptor is not open";
            return false;
        }
        
        // 检查io_service是否正在运行
        if (server_->io_service.stopped()) {
            BOOST_LOG_TRIVIAL(debug) << "Health check failed: io_service is stopped";
            return false;
        }
        
        // 尝试创建一个测试连接来验证服务器是否真正响应
        boost::asio::io_service test_io_service;
        boost::asio::ip::tcp::socket test_socket(test_io_service);
        boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::address::from_string("127.0.0.1"), port);
        
        boost::system::error_code ec;
        test_socket.connect(endpoint, ec);
        
        if (!ec) {
            test_socket.close();
            BOOST_LOG_TRIVIAL(debug) << "Health check passed: test connection successful on port " << port;
            return true;
        }
        
        BOOST_LOG_TRIVIAL(debug) << "Health check failed: test connection failed with error: " << ec.message();
        return false;
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(debug) << "Health check failed with exception: " << e.what();
        return false;
    }
}

void HttpServer::start_health_check()
{
    std::lock_guard<std::mutex> lock(m_health_check_mutex);
    
    if (m_health_check_enabled) {
        BOOST_LOG_TRIVIAL(info) << "Health check is already running";
        return; // 已经在运行
    }
    
    BOOST_LOG_TRIVIAL(info) << "Starting HTTP server health check with interval: " << m_health_check_interval << "ms";
    m_health_check_enabled = true;
    m_health_check_thread = create_thread([this] {
        set_current_thread_name("http_health_check");
        
        while (true) {
            // 检查是否应该继续运行
            bool should_continue;
            int current_interval;
            {
                std::lock_guard<std::mutex> lock(m_health_check_mutex);
                should_continue = m_health_check_enabled;
                current_interval = m_health_check_interval;
            }
            
            if (!should_continue) {
                break;
            }
            
            // 使用条件变量等待，可以响应间隔变化
            {
                std::unique_lock<std::mutex> lock(m_health_check_mutex);
                if (m_health_check_cv.wait_for(lock, std::chrono::milliseconds(current_interval), 
                    [this] { return !m_health_check_enabled; })) {
                    // 如果等待被中断（健康检查被禁用），退出循环
                    break;
                }
            }
            
            // 再次检查是否应该继续运行
            {
                std::lock_guard<std::mutex> lock(m_health_check_mutex);
                if (!m_health_check_enabled) {
                    break;
                }
            }
            
            // 检查服务器是否健康，或者服务器是否已经停止运行
            if ((start_http_server && !is_healthy()) || !start_http_server) {
                BOOST_LOG_TRIVIAL(warning) << "HTTP server health check failed or server stopped, performing restart...";
                try {
                    // 在健康检查线程中直接执行重启，避免通过标志传递
                    restart();
                    BOOST_LOG_TRIVIAL(info) << "HTTP server restart completed by health check thread";
                } catch (const std::exception& e) {
                    BOOST_LOG_TRIVIAL(error) << "Failed to restart HTTP server: " << e.what();
                    std::string error_msg = "HTTP server restart failed after health check on port " + std::to_string(port) + ": " + e.what();
                    Slic3r::sentryReportLog(Slic3r::SENTRY_LOG_ERROR, error_msg.c_str(), BP_LOCAL_SERVER);
                }
            } else if (start_http_server) {
                BOOST_LOG_TRIVIAL(debug) << "HTTP server health check passed";
            }
        }
        BOOST_LOG_TRIVIAL(info) << "Health check thread stopped";
    });
}

void HttpServer::stop_health_check()
{
    bool was_running = false;
    {
        std::lock_guard<std::mutex> lock(m_health_check_mutex);
        
        if (!m_health_check_enabled) {
            BOOST_LOG_TRIVIAL(debug) << "Health check is not running";
            return;
        }
        
        BOOST_LOG_TRIVIAL(info) << "Stopping HTTP server health check...";
        m_health_check_enabled = false;
        was_running = true;
        
        // 通知条件变量，确保健康检查线程能够立即响应停止信号
        m_health_check_cv.notify_all();
    } // 锁在这里自动释放
    
    if (was_running && m_health_check_thread.joinable()) {
        m_health_check_thread.join();
        BOOST_LOG_TRIVIAL(info) << "Health check thread joined successfully";
    }
}

void HttpServer::start_restart_check()
{
    std::lock_guard<std::mutex> lock(m_health_check_mutex);
    
    if (m_restart_check_enabled) {
        BOOST_LOG_TRIVIAL(info) << "Restart check is already running";
        return;
    }
    
    BOOST_LOG_TRIVIAL(info) << "Starting HTTP server restart check...";
    m_restart_check_enabled = true;
    m_restart_check_thread = create_thread([this] {
        set_current_thread_name("http_restart_check");
        
        while (true) {
            // 检查是否应该继续运行
            bool should_continue;
            {
                std::lock_guard<std::mutex> lock(m_health_check_mutex);
                should_continue = m_restart_check_enabled;
            }
            
            if (!should_continue) {
                break;
            }
            
            // 检查是否有重启请求
            if (is_restart_requested()) {
                BOOST_LOG_TRIVIAL(warning) << "HTTP server restart requested by health check, clearing restart flag...";
                // 清除重启请求标志，避免重复处理
                {
                    std::lock_guard<std::mutex> lock(m_health_check_mutex);
                    m_restart_requested = false;
                }
                
                // 在重启检查线程中，我们只负责清理标志，不直接调用restart()
                // 实际的重启操作由主线程或其他机制来处理
                BOOST_LOG_TRIVIAL(info) << "Restart flag cleared, restart should be handled externally";
            }
            
            // 等待一段时间再检查
            std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        }
        BOOST_LOG_TRIVIAL(info) << "Restart check thread stopped";
    });
}

void HttpServer::stop_restart_check()
{
    bool was_running = false;
    {
        std::lock_guard<std::mutex> lock(m_health_check_mutex);
        
        if (!m_restart_check_enabled) {
            BOOST_LOG_TRIVIAL(debug) << "Restart check is not running";
            return;
        }
        
        BOOST_LOG_TRIVIAL(info) << "Stopping HTTP server restart check...";
        m_restart_check_enabled = false;
        was_running = true;
    }
    
    if (was_running && m_restart_check_thread.joinable()) {
        m_restart_check_thread.join();
        BOOST_LOG_TRIVIAL(info) << "Restart check thread joined successfully";
    }
}

void HttpServer::set_health_check_interval(int interval_ms)
{
    std::lock_guard<std::mutex> lock(m_health_check_mutex);
    
    if (interval_ms > 0) {
        BOOST_LOG_TRIVIAL(info) << "Changing health check interval from " << m_health_check_interval << "ms to " << interval_ms << "ms";
        m_health_check_interval = interval_ms;
        // 通知条件变量，使新的间隔值立即生效
        m_health_check_cv.notify_all();
    } else {
        BOOST_LOG_TRIVIAL(warning) << "Invalid health check interval: " << interval_ms << "ms, must be positive";
    }
}

int HttpServer::get_health_check_interval() const
{
    std::lock_guard<std::mutex> lock(m_health_check_mutex);
    return m_health_check_interval;
}

bool HttpServer::is_health_check_enabled() const
{
    std::lock_guard<std::mutex> lock(m_health_check_mutex);
    return m_health_check_enabled;
}

bool HttpServer::is_restart_requested() const
{
    std::lock_guard<std::mutex> lock(m_health_check_mutex);
    return m_restart_requested;
}

void HttpServer::simulate_crash()
{
    BOOST_LOG_TRIVIAL(warning) << "Simulating HTTP server crash for testing restart mechanism...";
    
    try {
        if (server_) {
            // 关闭acceptor来模拟崩溃
            server_->acceptor.close();
            BOOST_LOG_TRIVIAL(info) << "Acceptor closed to simulate crash";
            
            // 停止io_service来模拟崩溃
            server_->io_service.stop();
            BOOST_LOG_TRIVIAL(info) << "IO service stopped to simulate crash";
        }
        
        // 设置标志，让健康检查能够检测到崩溃
        start_http_server = false;
        BOOST_LOG_TRIVIAL(info) << "Server state set to crashed for health check detection";
        
    } catch (const std::exception& e) {
        BOOST_LOG_TRIVIAL(error) << "Error during crash simulation: " << e.what();
    }
}

void HttpServer::set_request_handler(const std::function<std::shared_ptr<Response>(const std::string&)>& request_handler)
{
    this->m_request_handler = request_handler;
}

std::shared_ptr<HttpServer::Response> HttpServer::bbl_auth_handle_request(const std::string& url)
{
    BOOST_LOG_TRIVIAL(info) << "thirdparty_login: get_response";

    if (boost::contains(url, "access_token")) {
        std::string   redirect_url           = url_get_param(url, "redirect_url");
        std::string   access_token           = url_get_param(url, "access_token");
        std::string   refresh_token          = url_get_param(url, "refresh_token");
        std::string   expires_in_str         = url_get_param(url, "expires_in");
        std::string   refresh_expires_in_str = url_get_param(url, "refresh_expires_in");
        NetworkAgent* agent                  = wxGetApp().getAgent();

        unsigned int http_code;
        std::string  http_body;
        int          result = agent->get_my_profile(access_token, &http_code, &http_body);
        if (result == 0) {
            std::string user_id;
            std::string user_name;
            std::string user_account;
            std::string user_avatar;
            try {
                json user_j = json::parse(http_body);
                if (user_j.contains("uidStr"))
                    user_id = user_j["uidStr"].get<std::string>();
                if (user_j.contains("name"))
                    user_name = user_j["name"].get<std::string>();
                if (user_j.contains("avatar"))
                    user_avatar = user_j["avatar"].get<std::string>();
                if (user_j.contains("account"))
                    user_account = user_j["account"].get<std::string>();
            } catch (const std::exception& e) {
                BOOST_LOG_TRIVIAL(error) << "Failed to parse user profile JSON: " << e.what();
                std::string error_msg = "User profile JSON parse error: " + std::string(e.what());
                Slic3r::sentryReportLog(Slic3r::SENTRY_LOG_ERROR, error_msg.c_str(), BP_LOCAL_SERVER);
            }
            json j;
            j["data"]["refresh_token"]      = refresh_token;
            j["data"]["token"]              = access_token;
            j["data"]["expires_in"]         = expires_in_str;
            j["data"]["refresh_expires_in"] = refresh_expires_in_str;
            j["data"]["user"]["uid"]        = user_id;
            j["data"]["user"]["name"]       = user_name;
            j["data"]["user"]["account"]    = user_account;
            j["data"]["user"]["avatar"]     = user_avatar;
            agent->change_user(j.dump());
            if (agent->is_user_login()) {
                wxGetApp().request_user_login(1);
            }
            GUI::wxGetApp().CallAfter([] { wxGetApp().ShowUserLogin(false); });
            std::string location_str = (boost::format("%1%?result=success") % redirect_url).str();
            return std::make_shared<ResponseRedirect>(location_str);
        } else {
            std::string error_str    = "get_user_profile_error_" + std::to_string(result);
            std::string location_str = (boost::format("%1%?result=fail&error=%2%") % redirect_url % error_str).str();
            return std::make_shared<ResponseRedirect>(location_str);
        }
    } else {
        return std::make_shared<ResponseNotFound>();
    }
}

std::shared_ptr<HttpServer::Response> HttpServer::web_server_handle_request(const std::string& url)
{
    BOOST_LOG_TRIVIAL(info) << "Handling file request for URL: " << url;

    std::string file_path = map_url_to_file_path(url);

    BOOST_LOG_TRIVIAL(info) << "Handling file_path request for URL: " << file_path;
    return std::make_shared<ResponseFile>(file_path);
}

std::string HttpServer::map_url_to_file_path(const std::string& url)
{
    if (url.find("..") != std::string::npos) {
        return "";
    }

    wxString trimmed_url = wxString::FromUTF8(url);

    size_t question_mark = trimmed_url.find('?');
    if (question_mark != wxString::npos) {
        trimmed_url = trimmed_url.substr(0, question_mark);
    }

    if (trimmed_url == "/") {
        trimmed_url = "/flutter_web/index.html"; // 默认首页
    } else if (trimmed_url.substr(0, 11) == "/localfile/") {
        auto real_path = trimmed_url.substr(11);
        return real_path.ToStdString(wxConvUTF8);
    }
    auto data_web_path = boost::filesystem::path(data_dir()) / "web";
    if (!boost::filesystem::exists(data_web_path / "flutter_web")) {
        auto source_path = boost::filesystem::path(resources_dir()) / "web" / "flutter_web";
        auto target_path = data_web_path / "flutter_web";
        copy_directory_recursively(source_path, target_path);
    }

    if (trimmed_url.find("flutter_web") == std::string::npos) {
        wxString res = wxString::FromUTF8(resources_dir()) + trimmed_url;
        return res.ToStdString(wxConvUTF8);
    } else {
        wxString res = wxString::FromUTF8(data_dir()) + trimmed_url;
        return res.ToStdString(wxConvUTF8);
    }
}

void HttpServer::ResponseRedirect::write_response(std::stringstream& ssOut)
{
    const std::string sHTML          = "<html><body><p>redirect to url </p></body></html>";
    size_t            content_length = sHTML.size(); // 字节长度（与字符数相同，因无多字节字符）

    ssOut << "HTTP/1.1 302 Found\r\n";
    ssOut << "Location: " << location_str << "\r\n";
    ssOut << "Content-Type: text/html\r\n";
    ssOut << "Content-Length: " << content_length << "\r\n"; // 正确计算长度
    ssOut << "Access-Control-Allow-Origin: *\r\n";           // CORS头
    ssOut << "\r\n";                                         // 头和主体之间的空行（必须）
    ssOut << sHTML;                                          // 响应体（长度必须匹配）
}

void HttpServer::ResponseNotFound::write_response(std::stringstream& ssOut)
{
    const std::string sHTML          = "<html><body><h1>404 Not Found</h1><p>There's nothing here.</p></body></html>";
    size_t            content_length = sHTML.size(); // 字节长度

    ssOut << "HTTP/1.1 404 Not Found\r\n";
    ssOut << "Content-Type: text/html\r\n";
    ssOut << "Content-Length: " << content_length << "\r\n"; // 正确计算长度
    ssOut << "Access-Control-Allow-Origin: *\r\n";           // CORS头
    ssOut << "\r\n";                                         // 头和主体之间的空行（必须）
    ssOut << sHTML;                                          // 响应体（长度必须匹配）
}

void HttpServer::ResponseFile::write_response(std::stringstream& ssOut)
{
    // 将UTF-8路径转换为适合文件系统操作的编码，自动适配Windows的UTF-8模式
    std::string system_file_path = utf8_to_filesystem_encoding(file_path);
    
    std::ifstream file(system_file_path, std::ios::binary);
    if (!file) {
        ResponseNotFound notFoundResponse;
        notFoundResponse.write_response(ssOut);
        return;
    }

    // 读取文件内容并计算长度（关键：使用字节长度）
    std::ostringstream fileStream;
    fileStream << file.rdbuf();
    std::string fileContent    = fileStream.str();
    size_t      content_length = fileContent.size(); // 字节长度，非字符数

    // 确定Content-Type（保持原有逻辑）
    std::string content_type = "application/octet-stream";
    if (ends_with(file_path, ".html"))
        content_type = "text/html";
    else if (ends_with(file_path, ".css"))
        content_type = "text/css";
    else if (ends_with(file_path, ".js"))
        content_type = "text/javascript";
    else if (ends_with(file_path, ".png"))
        content_type = "image/png";
    else if (ends_with(file_path, ".jpg"))
        content_type = "image/jpeg";
    else if (ends_with(file_path, ".gif"))
        content_type = "image/gif";
    else if (ends_with(file_path, ".svg"))
        content_type = "image/svg+xml";
    else if (ends_with(file_path, ".ttf"))
        content_type = "application/x-font-ttf";
    else if (ends_with(file_path, ".json"))
        content_type = "application/json";
    else if (ends_with(file_path, ".webp"))
        content_type = "image/webp";
    else if (ends_with(file_path, ".woff"))
        content_type = "font/woff";
    else if (ends_with(file_path, ".woff2"))
        content_type = "font/woff2";

    // 构造响应头（严格使用\r\n，头结束后空行）
    ssOut << "HTTP/1.1 200 OK\r\n";
    ssOut << "Content-Type: " << content_type << "\r\n";
    ssOut << "Content-Length: " << content_length << "\r\n"; // 必须与实际内容长度一致
    ssOut << "Access-Control-Allow-Origin: *\r\n";           // CORS头
    ssOut << "Access-Control-Allow-Methods: GET, POST, OPTIONS\r\n";
    ssOut << "Access-Control-Allow-Headers: Content-Type, Authorization\r\n";
    ssOut << "\r\n";      // 头和主体之间的空行（必须）
    ssOut << fileContent; // 响应体（长度必须与Content-Length一致）
}

}} // namespace Slic3r::GUI