#include "NetworkTestDialog.hpp"
#include "I18N.hpp"

#include "libslic3r/Utils.hpp"
#include "GUI.hpp"
#include "GUI_App.hpp"
#include "I18N.hpp"
#include "slic3r/Utils/Http.hpp"
#include "libslic3r/AppConfig.hpp"
#include <wx/regex.h>
#include <boost/asio.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/log/trivial.hpp>
#include <chrono>
#include <vector>
#include <cstdio>
#include <memory>
#ifndef _WIN32
#include <sys/wait.h>
#endif

namespace Slic3r {
namespace GUI {

wxDECLARE_EVENT(EVT_UPDATE_RESULT, wxCommandEvent);

wxDEFINE_EVENT(EVT_UPDATE_RESULT, wxCommandEvent);

static wxString NA_STR = _L("N/A");

NetworkTestDialog::NetworkTestDialog(wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style)
    : DPIDialog(parent,wxID_ANY,from_u8((boost::format(_utf8(L("Network Test")))).str()),wxDefaultPosition,
            wxSize(1000, 700),
            /*wxCAPTION*/wxDEFAULT_DIALOG_STYLE|wxMAXIMIZE_BOX|wxMINIMIZE_BOX|wxRESIZE_BORDER)
{
	// Create a self-managing shared_ptr for weak_ptr support
	// Note: This creates a self-reference, so we need to break it in destructor
	self_ptr = std::shared_ptr<NetworkTestDialog>(this, [](NetworkTestDialog*) { /* custom deleter - do nothing, object is stack-allocated */ });
	weak_this = self_ptr;
    this->SetBackgroundColour(wxColour(255, 255, 255));

	this->SetSizeHints(wxDefaultSize, wxDefaultSize);

	wxBoxSizer* main_sizer;
	main_sizer = new wxBoxSizer(wxVERTICAL);

	wxBoxSizer* top_sizer = create_top_sizer(this);
	main_sizer->Add(top_sizer, 0, wxEXPAND, 5);

	wxBoxSizer* info_sizer = create_info_sizer(this);
	main_sizer->Add(info_sizer, 0, wxEXPAND, 5);

	wxBoxSizer* content_sizer = create_content_sizer(this);
	main_sizer->Add(content_sizer, 0, wxEXPAND, 5);

	wxBoxSizer* result_sizer = create_result_sizer(this);
	main_sizer->Add(result_sizer, 1, wxEXPAND, 5);

	set_default();

	init_bind();

	this->SetSizer(main_sizer);
	this->Layout();

	this->Centre(wxBOTH);
    wxGetApp().UpdateDlgDarkUI(this);
}

wxBoxSizer* NetworkTestDialog::create_top_sizer(wxWindow* parent)
{
	auto sizer = new wxBoxSizer(wxVERTICAL);

	auto line_sizer = new wxBoxSizer(wxHORIZONTAL);
	btn_start = new Button(this, _L("Start Test Multi-Thread"));
    btn_start->SetStyle(ButtonStyle::Confirm, ButtonType::Window);
	line_sizer->Add(btn_start, 0, wxALL, 5);

	btn_start_sequence = new Button(this, _L("Start Test Single-Thread"));
    btn_start_sequence->SetStyle(ButtonStyle::Regular, ButtonType::Window);

	line_sizer->Add(btn_start_sequence, 0, wxALL, 5);

	btn_download_log = new Button(this, _L("Export Log"));
    btn_download_log->SetStyle(ButtonStyle::Regular, ButtonType::Window);
	line_sizer->Add(btn_download_log, 0, wxALL, 5);
	btn_download_log->Hide();

	btn_clear_log = new Button(this, _L("Clear Log"));
    btn_clear_log->SetStyle(ButtonStyle::Regular, ButtonType::Window);
	line_sizer->Add(btn_clear_log, 0, wxALL, 5);

	btn_start->Bind(wxEVT_BUTTON, [weak_this = weak_this](wxCommandEvent &evt) {
			if (auto self = weak_this.lock()) {
				self->start_all_job();
			}
		});
	btn_start_sequence->Bind(wxEVT_BUTTON, [weak_this = weak_this](wxCommandEvent &evt) {
			if (auto self = weak_this.lock()) {
				self->start_all_job_sequence();
			}
		});
	btn_clear_log->Bind(wxEVT_BUTTON, [weak_this = weak_this](wxCommandEvent &evt) {
		if (auto self = weak_this.lock()) {
			if (self->txt_log) {
				self->txt_log->Clear();
			}
		}
	});
	sizer->Add(line_sizer, 0, wxEXPAND, 5);
	return sizer;
}

wxBoxSizer* NetworkTestDialog::create_info_sizer(wxWindow* parent)
{
	auto sizer = new wxBoxSizer(wxVERTICAL);

	text_basic_info = new wxStaticText(this, wxID_ANY, _L("Basic Info"), wxDefaultPosition, wxDefaultSize, 0);
	text_basic_info->Wrap(-1);
	sizer->Add(text_basic_info, 0, wxALL, 5);

	wxBoxSizer* version_sizer = new wxBoxSizer(wxHORIZONTAL);
	text_version_title = new wxStaticText(this, wxID_ANY, _L("Snapmaker Orca Version:"), wxDefaultPosition, wxDefaultSize, 0);
	text_version_title->Wrap(-1);
	version_sizer->Add(text_version_title, 0, wxALL, 5);

	wxString text_version = get_studio_version();
	text_version_val = new wxStaticText(this, wxID_ANY, text_version, wxDefaultPosition, wxDefaultSize, 0);
	text_version_val->Wrap(-1);
	version_sizer->Add(text_version_val, 0, wxALL, 5);
	sizer->Add(version_sizer, 1, wxEXPAND, 5);

	wxBoxSizer* sys_sizer = new wxBoxSizer(wxHORIZONTAL);

	txt_sys_info_title = new wxStaticText(this, wxID_ANY, _L("System Version:"), wxDefaultPosition, wxDefaultSize, 0);
	txt_sys_info_title->Wrap(-1);
	sys_sizer->Add(txt_sys_info_title, 0, wxALL, 5);

	txt_sys_info_value = new wxStaticText(this, wxID_ANY, get_os_info(), wxDefaultPosition, wxDefaultSize, 0);
	txt_sys_info_value->Wrap(-1);
	sys_sizer->Add(txt_sys_info_value, 0, wxALL, 5);

	sizer->Add(sys_sizer, 1, wxEXPAND, 5);

	wxBoxSizer* line_sizer = new wxBoxSizer(wxHORIZONTAL);
	txt_dns_info_title = new wxStaticText(this, wxID_ANY, _L("DNS Server:"), wxDefaultPosition, wxDefaultSize, 0);
	txt_dns_info_title->Wrap(-1);
	txt_dns_info_title->Hide();
	line_sizer->Add(txt_dns_info_title, 0, wxALL, 5);

	txt_dns_info_value = new wxStaticText(this, wxID_ANY, get_dns_info(), wxDefaultPosition, wxDefaultSize, 0);
	txt_dns_info_value->Hide();
	line_sizer->Add(txt_dns_info_value, 0, wxALL, 5);
	sizer->Add(line_sizer, 1, wxEXPAND, 5);

	return sizer;
}

wxBoxSizer* NetworkTestDialog::create_content_sizer(wxWindow* parent)
{
	auto sizer = new wxBoxSizer(wxVERTICAL);

	wxFlexGridSizer* grid_sizer;
	grid_sizer = new wxFlexGridSizer(0, 3, 0, 0);
	grid_sizer->SetFlexibleDirection(wxBOTH);
	grid_sizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);

	btn_link = new Button(this, _L("Test Snapmaker Orca(GitHub)"));
    btn_link->SetStyle(ButtonStyle::Regular, ButtonType::Window);
	grid_sizer->Add(btn_link, 0, wxEXPAND | wxALL, 5);

	text_link_title = new wxStaticText(this, wxID_ANY, _L("Test Snapmaker Orca(GitHub):"), wxDefaultPosition, wxDefaultSize, 0);
	text_link_title->Wrap(-1);
	grid_sizer->Add(text_link_title, 0, wxALIGN_RIGHT | wxALL | wxALIGN_CENTER_VERTICAL, 5);

	text_link_val = new wxStaticText(this, wxID_ANY, _L("N/A"), wxDefaultPosition, wxDefaultSize, 0);
	text_link_val->Wrap(-1);
	grid_sizer->Add(text_link_val, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);

	btn_bing = new Button(this, _L("Test bing.com"));
    btn_bing->SetStyle(ButtonStyle::Regular, ButtonType::Window);
	grid_sizer->Add(btn_bing, 0, wxEXPAND | wxALL, 5);

    text_bing_title = new wxStaticText(this, wxID_ANY, _L("Test bing.com:"), wxDefaultPosition, wxDefaultSize, 0);

	text_bing_title->Wrap(-1);
	grid_sizer->Add(text_bing_title, 0, wxALIGN_RIGHT | wxALL | wxALIGN_CENTER_VERTICAL, 5);

	text_bing_val = new wxStaticText(this, wxID_ANY, _L("N/A"), wxDefaultPosition, wxDefaultSize, 0);
	text_bing_val->Wrap(-1);
	grid_sizer->Add(text_bing_val, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);

	// LAN Device Test
	btn_lan_mqtt = new Button(this, _L("Test LAN Device"));
    btn_lan_mqtt->SetStyle(ButtonStyle::Regular, ButtonType::Window);
	grid_sizer->Add(btn_lan_mqtt, 0, wxEXPAND | wxALL, 5);

	text_lan_mqtt_title = new wxStaticText(this, wxID_ANY, _L("Test LAN Device:"), wxDefaultPosition, wxDefaultSize, 0);
	text_lan_mqtt_title->Wrap(-1);
	grid_sizer->Add(text_lan_mqtt_title, 0, wxALIGN_RIGHT | wxALL | wxALIGN_CENTER_VERTICAL, 5);

	text_lan_mqtt_val = new wxStaticText(this, wxID_ANY, _L("N/A"), wxDefaultPosition, wxDefaultSize, 0);
	text_lan_mqtt_val->Wrap(-1);
	grid_sizer->Add(text_lan_mqtt_val, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);

	// Cloud Server Test
	btn_cloud_mqtt = new Button(this, _L("Test Cloud Server"));
    btn_cloud_mqtt->SetStyle(ButtonStyle::Regular, ButtonType::Window);
	grid_sizer->Add(btn_cloud_mqtt, 0, wxEXPAND | wxALL, 5);

	text_cloud_mqtt_title = new wxStaticText(this, wxID_ANY, _L("Test Cloud Server:"), wxDefaultPosition, wxDefaultSize, 0);
	text_cloud_mqtt_title->Wrap(-1);
	grid_sizer->Add(text_cloud_mqtt_title, 0, wxALIGN_RIGHT | wxALL | wxALIGN_CENTER_VERTICAL, 5);

	text_cloud_mqtt_val = new wxStaticText(this, wxID_ANY, _L("N/A"), wxDefaultPosition, wxDefaultSize, 0);
	text_cloud_mqtt_val->Wrap(-1);
	grid_sizer->Add(text_cloud_mqtt_val, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);

	// Login API Test
	btn_login_api = new Button(this, _L("Test Login API"));
    btn_login_api->SetStyle(ButtonStyle::Regular, ButtonType::Window);
	grid_sizer->Add(btn_login_api, 0, wxEXPAND | wxALL, 5);

	text_login_api_title = new wxStaticText(this, wxID_ANY, _L("Test Login API:"), wxDefaultPosition, wxDefaultSize, 0);
	text_login_api_title->Wrap(-1);
	grid_sizer->Add(text_login_api_title, 0, wxALIGN_RIGHT | wxALL | wxALIGN_CENTER_VERTICAL, 5);

	text_login_api_val = new wxStaticText(this, wxID_ANY, _L("N/A"), wxDefaultPosition, wxDefaultSize, 0);
	text_login_api_val->Wrap(-1);
	grid_sizer->Add(text_login_api_val, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);

	// Upload API Test
	btn_upload_api = new Button(this, _L("Test Upload API"));
    btn_upload_api->SetStyle(ButtonStyle::Regular, ButtonType::Window);
	grid_sizer->Add(btn_upload_api, 0, wxEXPAND | wxALL, 5);

	text_upload_api_title = new wxStaticText(this, wxID_ANY, _L("Test Upload API:"), wxDefaultPosition, wxDefaultSize, 0);
	text_upload_api_title->Wrap(-1);
	grid_sizer->Add(text_upload_api_title, 0, wxALIGN_RIGHT | wxALL | wxALIGN_CENTER_VERTICAL, 5);

	text_upload_api_val = new wxStaticText(this, wxID_ANY, _L("N/A"), wxDefaultPosition, wxDefaultSize, 0);
	text_upload_api_val->Wrap(-1);
	grid_sizer->Add(text_upload_api_val, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);

	sizer->Add(grid_sizer, 1, wxEXPAND, 5);

	btn_link->Bind(wxEVT_BUTTON, [weak_this = weak_this](wxCommandEvent& evt) {
		if (auto self = weak_this.lock()) {
			self->start_test_github_thread();
		}
	});

	btn_bing->Bind(wxEVT_BUTTON, [weak_this = weak_this](wxCommandEvent& evt) {
		if (auto self = weak_this.lock()) {
			self->start_test_bing_thread();
		}
	});

	btn_lan_mqtt->Bind(wxEVT_BUTTON, [weak_this = weak_this](wxCommandEvent& evt) {
		if (auto self = weak_this.lock()) {
			self->start_test_lan_mqtt_thread();
		}
	});

	btn_cloud_mqtt->Bind(wxEVT_BUTTON, [weak_this = weak_this](wxCommandEvent& evt) {
		if (auto self = weak_this.lock()) {
			self->start_test_cloud_mqtt_thread();
		}
	});

	btn_login_api->Bind(wxEVT_BUTTON, [weak_this = weak_this](wxCommandEvent& evt) {
		if (auto self = weak_this.lock()) {
			self->start_test_login_api_thread();
		}
	});

	btn_upload_api->Bind(wxEVT_BUTTON, [weak_this = weak_this](wxCommandEvent& evt) {
		if (auto self = weak_this.lock()) {
			self->start_test_upload_api_thread();
		}
	});

	return sizer;
}
wxBoxSizer* NetworkTestDialog::create_result_sizer(wxWindow* parent)
{
	auto sizer = new wxBoxSizer(wxVERTICAL);
	text_result = new wxStaticText(this, wxID_ANY, _L("Log Info"), wxDefaultPosition, wxDefaultSize, 0);
	text_result->Wrap(-1);
	sizer->Add(text_result, 0, wxALL, 5);

	txt_log = new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE);
	sizer->Add(txt_log, 1, wxALL | wxEXPAND, 5);
	return sizer;
}

NetworkTestDialog::~NetworkTestDialog()
{
	m_closing.store(true);
	m_download_cancel = true;
	cleanup_threads();

	// Small delay to allow any in-flight update_status calls to complete
	// before destroying the shared_ptr control block
	boost::this_thread::sleep_for(boost::chrono::milliseconds(50));

	// Break the self-reference to avoid issues
	self_ptr.reset();
}

void NetworkTestDialog::init_bind()
{
	Bind(EVT_UPDATE_RESULT, [weak_this = weak_this](wxCommandEvent& evt) {
		auto self = weak_this.lock();
		if (!self || self->m_closing.load()) return;

		if (evt.GetInt() == TEST_ORCA_JOB) {
			self->text_link_val->SetLabelText(evt.GetString());
		} else if (evt.GetInt() == TEST_BING_JOB) {
			self->text_bing_val->SetLabelText(evt.GetString());
		} else if (evt.GetInt() == TEST_LAN_MQTT_JOB) {
			self->text_lan_mqtt_val->SetLabelText(evt.GetString());
		} else if (evt.GetInt() == TEST_CLOUD_MQTT_JOB) {
			self->text_cloud_mqtt_val->SetLabelText(evt.GetString());
		} else if (evt.GetInt() == TEST_LOGIN_API_JOB) {
			self->text_login_api_val->SetLabelText(evt.GetString());
		} else if (evt.GetInt() == TEST_UPLOAD_API_JOB) {
			self->text_upload_api_val->SetLabelText(evt.GetString());
		}

		std::time_t t = std::time(0);
		std::tm* now_time = std::localtime(&t);
		std::stringstream buf;
		buf << std::put_time(now_time, "%a %b %d %H:%M:%S");
		wxString info = wxString(buf.str()) + ": " + evt.GetString() + "\n";
		try {
			if (!self->m_closing.load() && self->txt_log) {
				self->txt_log->AppendText(info);
			}
		}
		catch (std::exception& e) {
			BOOST_LOG_TRIVIAL(error) << "Unkown Exception in print_log, exception=" << e.what();
			return;
		}
		catch (...) {
			BOOST_LOG_TRIVIAL(error) << "Unkown Exception in print_log";
			return;
		}
		return;
	});

	Bind(wxEVT_CLOSE_WINDOW, &NetworkTestDialog::on_close, this);
}

wxString NetworkTestDialog::get_os_info()
{
	int major = 0, minor = 0, micro = 0;
	wxGetOsVersion(&major, &minor, &micro);
	std::string os_version = (boost::format("%1%.%2%.%3%") % major % minor % micro).str();
	wxString text_sys_version = wxGetOsDescription() + wxString::Format("%d.%d.%d", major, minor, micro);
	return text_sys_version;
}


wxString NetworkTestDialog::get_dns_info()
{
	return NA_STR;
}

void NetworkTestDialog::start_all_job()
{
	start_test_github_thread();
	start_test_bing_thread();
	start_test_lan_mqtt_thread();
	start_test_cloud_mqtt_thread();
	start_test_login_api_thread();
	start_test_upload_api_thread();
}

void NetworkTestDialog::start_all_job_sequence()
{
	if (m_sequence_job != nullptr) {
		update_status(-1, "Sequence test already running, please wait...");
		return;
	}

	// 在序列测试开始前，先弹出输入框获取局域网设备IP
	wxTextEntryDialog dlg(this,
		_L("Please enter the LAN device IP address for testing (leave empty to skip):"),
		_L("LAN Device Test - Sequence Mode"),
		"192.168.1.1",
		wxOK | wxCANCEL);

	wxString device_ip;
	if (dlg.ShowModal() == wxID_OK) {
		device_ip = dlg.GetValue().Trim();
	}

	m_sequence_job = new boost::thread([weak_this = weak_this, device_ip] {
		auto self = weak_this.lock();
		if (!self) return;
		self->update_status(-1, "========================================");
		self->update_status(-1, "Start sequence test (single-thread mode)");
		self->update_status(-1, "========================================");
		self->update_status(-1, "");

        self->start_test_url(TEST_BING_JOB, "Bing", "http://www.bing.com");
        if (self->m_closing.load()) return;

		self->update_status(-1, "");
		self->start_test_url(TEST_ORCA_JOB, "Snapmaker Orca(GitHub)", "https://github.com/Snapmaker/OrcaSlicer");
		if (self->m_closing.load()) return;

		// 如果用户输入了局域网设备IP，则进行测试
		if (!device_ip.IsEmpty()) {
			self->update_status(-1, "");
			self->start_test_telnet(TEST_LAN_MQTT_JOB, "LAN Device", device_ip, 1884);
			if (self->m_closing.load()) return;
		}

		// 测试云服务器
		wxString cloud_server = self->get_cloud_server_address();
		if (!cloud_server.IsEmpty()) {
			self->update_status(-1, "");
			self->start_test_telnet(TEST_CLOUD_MQTT_JOB, "Cloud Server", cloud_server, 8883);
		}
		if (self->m_closing.load()) return;

		// 测试登录API
		self->update_status(-1, "");
		auto app_config = wxGetApp().app_config;
		std::string region = app_config->get("region");
		wxString login_api_url = (region == "Chinese Mainland" || region == "China") ? "https://id.snapmaker.cn" : "https://id.snapmaker.com";
		self->start_test_url(TEST_LOGIN_API_JOB, "Login API", login_api_url);
		if (self->m_closing.load()) return;

		// 测试上传API
		self->update_status(-1, "");
		wxString upload_api_url = (region == "Chinese Mainland" || region == "China") ? "https://public.resource.snapmaker.cn" : "https://public.resource.snapmaker.com";
		self->start_test_url(TEST_UPLOAD_API_JOB, "Upload API", upload_api_url);
		if (self->m_closing.load()) return;

		self->update_status(-1, "");
		self->update_status(-1, "========================================");
		self->update_status(-1, "Sequence test completed");
		self->update_status(-1, "========================================");
	});
}

void NetworkTestDialog::start_test_url(TestJob job, wxString name, wxString url)
{
	m_in_testing[job].store(true);

	update_status(-1, "");
	update_status(-1, "========================================");
	wxString info = "test " + name + " start...";
	update_status(job, info);

	Slic3r::Http http = Slic3r::Http::get(url.ToStdString());
	info = "[test " + name + "]: url=" + url;
    update_status(-1, info);
	update_status(-1, "");

    int result = -1;
	auto weak_self = weak_this;
	http.timeout_max(10)
		.on_complete([weak_self, &result, job](std::string body, unsigned status) {
			auto self = weak_self.lock();
			if (!self || self->m_closing.load()) return;
			try {
				if (status == 200) {
					result = 0;
				}
				// Upload API: 403 is OK (HTTPS resource with permission check)
				else if (job == TEST_UPLOAD_API_JOB && status == 403) {
					result = 0;
				}
			}
			catch (...) {
				;
			}
		})
		.on_ip_resolve([weak_self, name, job](std::string ip) {
			auto self = weak_self.lock();
			if (!self || self->m_closing.load()) return;
			wxString ip_report = "test " + name + " ip resolved = " + wxString::FromUTF8(ip);
			self->update_status(job, ip_report);
		})
		.on_error([weak_self, name, job](std::string body, std::string error, unsigned int status) {
		auto self = weak_self.lock();
		if (!self || self->m_closing.load()) return;
		// Upload API: 403 is OK (HTTPS resource with permission check)
		if (job == TEST_UPLOAD_API_JOB && status == 403) {
			self->update_status(job, "test " + name + " ok (403 - access restricted, but server reachable)");
			return;
		}
		wxString info = wxString::Format("status=%u, body=", status) + wxString::FromUTF8(body) + ", error=" + wxString::FromUTF8(error);
        self->update_status(job, "test " + name + " failed");
        self->update_status(-1, info);
	}).perform_sync();

	if (result == 0) {
        update_status(job, "test " + name + " ok");
    }

	update_status(-1, "========================================");
	update_status(-1, "");
	m_in_testing[job].store(false);
}

void NetworkTestDialog::start_test_ping_thread()
{
	test_job[TEST_PING_JOB] = new boost::thread([weak_this = weak_this] {
		auto self = weak_this.lock();
		if (!self) return;
		self->m_in_testing[TEST_PING_JOB].store(true);

		self->m_in_testing[TEST_PING_JOB].store(false);
	});
}

void NetworkTestDialog::start_test_ping(wxString server, TestJob job)
{
	update_status(-1, "");
	update_status(-1, "Starting ping test to " + server + "...");

	try {
#ifdef _WIN32
		// Windows: ping -n 4 <server>
		wxString ping_cmd = "ping -n 4 " + server;
		// Windows 可以使用 wxExecute
		wxArrayString output;
		wxArrayString errors;
		long exec_flags = wxEXEC_SYNC | wxEXEC_NODISABLE | wxEXEC_HIDE_CONSOLE;
		long result = wxExecute(ping_cmd, output, errors, exec_flags);
#else
		// Linux/Mac: ping -c 4 <server>
		// 使用 popen() 而不是 wxExecute，因为 wxExecute 在 macOS 上不能在异步线程中使用
		std::string ping_cmd = "ping -c 4 " + server.ToStdString();
		wxArrayString output;
		long result = -1;
		
		FILE* pipe = popen(ping_cmd.c_str(), "r");
		if (pipe != nullptr) {
			char buffer[1024];
			while (fgets(buffer, sizeof(buffer), pipe) != nullptr) {
				// 转换为 wxString 并添加到 output
				wxString line = wxString::FromUTF8(buffer);
				line.Trim();  // 移除换行符
				if (!line.IsEmpty()) {
					output.Add(line);
				}
			}
			int pclose_result = pclose(pipe);
			// pclose 返回的是命令的退出状态，需要检查 WEXITSTATUS
			if (WIFEXITED(pclose_result)) {
				result = WEXITSTATUS(pclose_result);
			} else {
				result = -1;
			}
		}
#endif

		if (result == 0 && output.GetCount() > 0) {
			// 解析ping输出（不输出每一行，减少UI更新）
			bool found_rtt = false;
			wxString rtt_info;
			int received = 0;
			int sent = 4;
			
			// macOS需要收集所有time值来计算平均值
			std::vector<double> time_values;

			for (size_t i = 0; i < output.GetCount(); i++) {
				wxString line = output[i];

				// 完全不输出ping详细日志，只解析数据

#ifdef _WIN32
				// Windows: 通用解析（支持所有语言）

				// 策略1: 查找统计行（包含多个 "= 数字" 的模式）
				// 这一行通常是：数据包: 已发送 = 4，已接收 = 4，丢失 = 0
				// 或：Packets: Sent = 4, Received = 4, Lost = 0
				// 特征：一行中有至少3个 "= 数字" 模式
				if (received == 0 && line.Contains("=") && !line.Contains("TTL")) {
					// 提取所有 "= 数字" 模式
					wxArrayString numbers;
					size_t pos = 0;
					while (pos < line.Length()) {
						// 查找等号
						size_t eq_pos = line.find('=', pos);
						if (eq_pos == wxString::npos) break;

						// 跳过等号后的空格
						size_t num_start = eq_pos + 1;
						while (num_start < line.Length() &&
						       (line[num_start] == ' ' || line[num_start] == '\t')) {
							num_start++;
						}

						// 提取数字
						wxString num_str;
						size_t num_pos = num_start;
						while (num_pos < line.Length() && wxIsdigit(line[num_pos])) {
							num_str += line[num_pos];
							num_pos++;
						}

						if (!num_str.IsEmpty()) {
							numbers.Add(num_str);
						}

						pos = num_pos + 1;
					}

					// 统计行特征：至少有3个数字（sent, received, lost）
					// 第2个数字是received（已接收）
					if (numbers.GetCount() >= 3) {
						long val;
						if (numbers[1].ToLong(&val)) {
							received = val;
						}
					}
				}

				// 策略2: 查找平均RTT行（包含 "平均" 或 "Average" 或多个ms）
				// 格式：最短 = 42ms，最长 = 45ms，平均 = 43ms
				// 或：Minimum = 42ms, Maximum = 45ms, Average = 43ms
				if (!found_rtt) {
					// 检查是否是平均/Average行（包含多个ms的行）
					int ms_count = 0;
					size_t search_pos = 0;
					while ((search_pos = line.find("ms", search_pos)) != wxString::npos) {
						ms_count++;
						search_pos += 2;
					}

					// 如果一行中有3个ms，很可能是RTT统计行
					// 提取最后一个数字作为平均RTT（避免显示乱码）
					if (ms_count >= 3) {
						wxString avg_rtt;
						// 从后往前找最后一个 "数字ms" 模式
						for (int i = line.Length() - 1; i >= 1; i--) {
							if (line[i] == 's' && line[i-1] == 'm') {
								// 找到ms，往前提取数字
								wxString num_str;
								int j = i - 2;
								while (j >= 0 && (wxIsdigit(line[j]) || line[j] == '.')) {
									num_str = line[j] + num_str;
									j--;
								}
								if (!num_str.IsEmpty()) {
									avg_rtt = num_str;
									break;
								}
							}
						}

						if (!avg_rtt.IsEmpty()) {
							found_rtt = true;
							rtt_info = avg_rtt + "ms (average)";
						}
					}
				}
#else
				// macOS格式: "64 bytes from 13.35.32.150: icmp_seq=519 ttl=244 time=57.030 ms"
				// 需要从每行提取 time=XX.XXX ms 并收集所有值
				if (line.Contains("time=")) {
					int time_pos = line.Find("time=");
					if (time_pos != wxNOT_FOUND) {
						wxString after_time = line.Mid(time_pos + 5);  // 跳过 "time="
						wxString time_str;
						// 提取数字（可能包含小数点）
						for (size_t j = 0; j < after_time.Length(); j++) {
							wxChar c = after_time[j];
							if (wxIsdigit(c) || c == '.') {
								time_str += c;
							} else if (c == ' ' || c == 'm') {
								// 遇到空格或 'm' (ms) 停止
								break;
							}
						}
						if (!time_str.IsEmpty()) {
							double time_val;
							if (time_str.ToDouble(&time_val)) {
								time_values.push_back(time_val);
								found_rtt = true;
							}
						}
					}
				}
				
				// Linux格式: "rtt min/avg/max/mdev = 1.234/5.678/9.012/1.234 ms"
				if (!found_rtt && line.Contains("rtt") && line.Contains("avg")) {
					found_rtt = true;
					// 提取平均值
					int avg_pos = line.Find("avg");
					if (avg_pos != wxNOT_FOUND) {
						wxString after_avg = line.Mid(avg_pos + 3);
						wxString num_str;
						size_t i = 0;
						// 跳过空格和等号
						while (i < after_avg.Length() && (after_avg[i] == ' ' || after_avg[i] == '\t' || after_avg[i] == '=')) {
							i++;
						}
						// 提取数字直到遇到斜杠或空格
						while (i < after_avg.Length() && (wxIsdigit(after_avg[i]) || after_avg[i] == '.')) {
							num_str += after_avg[i];
							i++;
						}
						if (!num_str.IsEmpty()) {
							rtt_info = num_str + "ms (average)";
						} else {
							rtt_info = line;
						}
					} else {
						rtt_info = line;
					}
				}
				
				// 统计格式: "4 packets transmitted, 4 received" (Linux/macOS通用)
				if (line.Contains("packets transmitted") && line.Contains("received")) {
					int pos_received = line.Find(" received");
					if (pos_received != wxNOT_FOUND) {
						wxString before = line.Mid(0, pos_received);
						wxString num_str;
						for (int j = before.Length() - 1; j >= 0; j--) {
							if (wxIsdigit(before[j])) {
								num_str = before[j] + num_str;
							} else if (!num_str.IsEmpty()) {
								break;
							}
						}
						long val;
						if (!num_str.IsEmpty() && num_str.ToLong(&val)) {
							received = val;
						}
					}
				}
				
				// macOS 可能还有统计行: "round-trip min/avg/max/stddev = 1.234/5.678/9.012/1.234 ms"
				if (!found_rtt && line.Contains("round-trip") && line.Contains("avg")) {
					found_rtt = true;
					int avg_pos = line.Find("avg");
					if (avg_pos != wxNOT_FOUND) {
						wxString after_avg = line.Mid(avg_pos + 3);
						wxString num_str;
						size_t i = 0;
						while (i < after_avg.Length() && (after_avg[i] == ' ' || after_avg[i] == '\t' || after_avg[i] == '=')) {
							i++;
						}
						while (i < after_avg.Length() && (wxIsdigit(after_avg[i]) || after_avg[i] == '.')) {
							num_str += after_avg[i];
							i++;
							if (i < after_avg.Length() && after_avg[i] == '/') break;  // 遇到斜杠停止
						}
						if (!num_str.IsEmpty()) {
							rtt_info = num_str + "ms (average)";
						} else {
							rtt_info = line;
						}
					} else {
						rtt_info = line;
					}
				}
#endif
			}

			// 如果收集了多个time值（macOS），计算平均值
			if (!time_values.empty()) {
				double sum = 0.0;
				for (double val : time_values) {
					sum += val;
				}
				double avg = sum / time_values.size();
				rtt_info = wxString::Format("%.3fms (average from %zu samples)", avg, time_values.size());
			} else if (found_rtt && rtt_info.IsEmpty()) {
				rtt_info = "N/A";
			}

			// 计算丢包率
			int packet_loss = ((sent - received) * 100) / sent;

			// 一次性输出所有结果，减少UI更新次数
			wxString summary = "\n";

			// 检查是否成功解析
			bool parse_success = (found_rtt || received > 0);

			if (parse_success) {
				// 成功解析了ping结果
				if (found_rtt && !rtt_info.IsEmpty()) {
					summary += "[OK] Ping round-trip time: " + rtt_info + "\n";
				}
				summary += wxString::Format("Packet loss: %d%% (%d/%d received)\n", packet_loss, received, sent);

				if (received > 0) {
					summary += wxString::Format("[OK] Ping test successful (%d/%d packets)", received, sent);
				} else {
					summary += "[FAIL] Ping test failed - 100% packet loss";
				}
			} else {
				// 无法解析ping输出
				summary += "[WARN] Cannot parse ping output - unusual format\n";
				summary += "[INFO] TCP connection test can still verify network connectivity";
			}

			update_status(-1, summary);

		} else {
			wxString error_summary = "\n[FAIL] Ping command failed or timed out";
#ifdef _WIN32
			for (size_t i = 0; i < errors.GetCount(); i++) {
				error_summary += "\nError: " + errors[i];
			}
#else
			if (output.GetCount() > 0) {
				error_summary += "\nOutput:\n";
				for (size_t i = 0; i < output.GetCount() && i < 5; i++) {
					error_summary += "  " + output[i] + "\n";
				}
			} else {
				error_summary += "\nNo output from ping command";
			}
#endif
			update_status(-1, error_summary);
		}

	} catch (const std::exception& e) {
		update_status(-1, wxString("\nPing exception: ") + wxString(e.what()));
	} catch (...) {
		update_status(-1, "\nPing test failed: unknown error");
	}
}

void NetworkTestDialog::start_test_telnet(TestJob job, wxString name, wxString server, int port)
{
	m_in_testing[job].store(true);

	// 添加分隔空行
	update_status(-1, "");
	update_status(-1, "========================================");

	wxString info = "test " + name + " start...";
	update_status(job, info);

	try {
		info = "[test " + name + "]: server=" + server + wxString::Format(", port=%d", port);
		update_status(-1, info);
		update_status(-1, ""); // 空行

		// ============================================
		// 第一步: Ping测试 - 测量网络层RTT
		// ============================================
		update_status(-1, "--- Step 1: Network Layer Test (ICMP Ping) ---");
		start_test_ping(server, job);

		if (m_closing.load()) {
			m_in_testing[job].store(false);
			return;
		}

		// 添加步骤间空行
		update_status(-1, "");

		// ============================================
		// 第二步: TCP连接测试 - 验证服务可用性
		// ============================================
		update_status(-1, "--- Step 2: Transport Layer Test (TCP Connection) ---");

		// 记录开始时间
		auto start_time = std::chrono::high_resolution_clock::now();

		boost::asio::io_context io_context;
		boost::asio::ip::tcp::socket socket(io_context);
		boost::asio::ip::tcp::resolver resolver(io_context);

		bool success = false;
		std::string error_msg;

		try {
			// 解析主机名
			auto resolve_start = std::chrono::high_resolution_clock::now();
			boost::asio::ip::tcp::resolver::results_type endpoints;

			try {
				endpoints = resolver.resolve(server.ToStdString(), std::to_string(port));
				auto resolve_end = std::chrono::high_resolution_clock::now();
				auto resolve_time = std::chrono::duration_cast<std::chrono::milliseconds>(resolve_end - resolve_start).count();

				update_status(-1, wxString::Format("DNS resolve time: %lld ms", resolve_time));
			} catch (const boost::system::system_error& e) {
				error_msg = (wxString("DNS resolve failed: ") + wxString(e.what())).ToStdString();
				throw;
			}

			// 连接到服务器
			auto connect_start = std::chrono::high_resolution_clock::now();
			boost::system::error_code ec;
			long long connect_time = 0;

			// 尝试连接到所有解析出的endpoint
			bool connected = false;
			for (auto& endpoint : endpoints) {
				if (m_closing.load()) break;

				socket.close(ec);
				socket.connect(endpoint, ec);

				if (!ec) {
					connected = true;
					auto connect_end = std::chrono::high_resolution_clock::now();
					connect_time = std::chrono::duration_cast<std::chrono::milliseconds>(connect_end - connect_start).count();

					update_status(job, "test " + name + " connected");
					update_status(-1, wxString::Format("[OK] TCP connection established in %lld ms", connect_time));
					break;
				}
			}

			if (!connected) {
				error_msg = (wxString("Connection failed: ") + wxString(ec.message())).ToStdString();
				throw boost::system::system_error(ec);
			}

			// 计算总时间
			auto end_time = std::chrono::high_resolution_clock::now();
			auto total_time = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();

			update_status(-1, wxString::Format("Total test time: %lld ms", total_time));

			// Calculate connection quality grade based on RTT
			int grade;
			wxString grade_desc;
			wxString grade_icon;

			if (connect_time <= 50) {
				grade = 1;
				grade_desc = "Excellent";
				grade_icon = "[Level 1]";
			} else if (connect_time <= 100) {
				grade = 2;
				grade_desc = "Good";
				grade_icon = "[Level 2]";
			} else if (connect_time <= 400) {
				grade = 3;
				grade_desc = "Fair";
				grade_icon = "[Level 3]";
			} else {
				grade = 4;
				grade_desc = "Poor";
				grade_icon = "[Level 4]";
			}

			// 添加空行
			update_status(-1, "");
			update_status(-1, "--- Test Summary ---");
			update_status(-1, "[OK] Network Layer: Ping test completed (see RTT above)");
			update_status(-1, wxString::Format("[OK] Transport Layer: TCP port %d is open and accepting connections", port));
			update_status(-1, wxString::Format("Connection Quality: %s %s (RTT: %lld ms)", grade_icon, grade_desc, connect_time));
			update_status(job, wxString::Format("test %s ok (%s - %s, RTT: %lld ms)", name, grade_icon, grade_desc, connect_time));

			success = true;

			// 关闭连接
			socket.close(ec);

		} catch (const boost::system::system_error& e) {
			if (error_msg.empty()) {
				error_msg = e.what();
			}
			update_status(-1, "");
			update_status(-1, "[FAIL] TCP connection error: " + wxString::FromUTF8(error_msg));
			update_status(-1, "Connection Quality: [Level 5] Failed (timeout or unreachable)");
			update_status(job, "test " + name + " failed ([Level 5] - timeout or unreachable)");
		} catch (const std::exception& e) {
			update_status(-1, "");
			update_status(-1, wxString("Exception: ") + wxString(e.what()));
			update_status(-1, "Connection Quality: [Level 5] Failed (exception)");
			update_status(job, "test " + name + " failed ([Level 5] - exception)");
		}

	} catch (...) {
		update_status(-1, "");
		update_status(-1, "Connection Quality: [Level 5] Failed (unknown error)");
		update_status(job, "test " + name + " failed ([Level 5] - unknown error)");
	}

	update_status(-1, "========================================");
	update_status(-1, ""); // 测试结束后的空行
	m_in_testing[job].store(false);
}

void NetworkTestDialog::start_test_lan_mqtt_thread()
{
	if (m_in_testing[TEST_LAN_MQTT_JOB].load()) {
		return;
	}

	// 弹出对话框让用户输入IP地址
	wxTextEntryDialog dlg(this,
		_L("Please enter the device IP address:"),
		_L("LAN Device Test"),
		"192.168.1.1",
		wxOK | wxCANCEL);

	if (dlg.ShowModal() != wxID_OK) {
		return;
	}

	wxString device_ip = dlg.GetValue().Trim();
	if (device_ip.IsEmpty()) {
		update_status(TEST_LAN_MQTT_JOB, "Invalid IP address");
		return;
	}

	if (test_job[TEST_LAN_MQTT_JOB] != nullptr && test_job[TEST_LAN_MQTT_JOB]->joinable()) {
		test_job[TEST_LAN_MQTT_JOB]->join();
		delete test_job[TEST_LAN_MQTT_JOB];
		test_job[TEST_LAN_MQTT_JOB] = nullptr;
	}

	test_job[TEST_LAN_MQTT_JOB] = new boost::thread([weak_this = weak_this, device_ip] {
		auto self = weak_this.lock();
		if (!self) return;
		// 测试局域网设备 - 端口默认1884
		self->start_test_telnet(TEST_LAN_MQTT_JOB, "LAN Device", device_ip, 1884);
	});
}

wxString NetworkTestDialog::get_cloud_server_address()
{
	auto app_config = wxGetApp().app_config;
	std::string region = app_config->get("region");
    if (region == "Chinese Mainland")
        return "a1su7rk2r6cmbq.ats.iot.cn-north-1.amazonaws.com.cn";
    else
        return "a1pr8yczi3n0se-ats.iot.us-west-1.amazonaws.com";
}

void NetworkTestDialog::start_test_cloud_mqtt_thread()
{
	if (m_in_testing[TEST_CLOUD_MQTT_JOB].load()) {
		return;
	}

	wxString cloud_server = get_cloud_server_address();

	if (cloud_server.IsEmpty()) {
		update_status(TEST_CLOUD_MQTT_JOB, "Cloud server not configured");
		update_status(-1, "Please configure cloud server address in get_cloud_server_address()");
		return;
	}

	if (test_job[TEST_CLOUD_MQTT_JOB] != nullptr && test_job[TEST_CLOUD_MQTT_JOB]->joinable()) {
		test_job[TEST_CLOUD_MQTT_JOB]->join();
		delete test_job[TEST_CLOUD_MQTT_JOB];
		test_job[TEST_CLOUD_MQTT_JOB] = nullptr;
	}

	test_job[TEST_CLOUD_MQTT_JOB] = new boost::thread([weak_this = weak_this, cloud_server] {
		auto self = weak_this.lock();
		if (!self) return;
		// 测试云服务器 - 使用telnet方式，端口8883
		self->start_test_telnet(TEST_CLOUD_MQTT_JOB, "Cloud Server", cloud_server, 8883);
	});
}
void NetworkTestDialog::start_test_github_thread()
{
    if (m_in_testing[TEST_ORCA_JOB].load())
        return;

	if (test_job[TEST_ORCA_JOB] != nullptr && test_job[TEST_ORCA_JOB]->joinable()) {
		test_job[TEST_ORCA_JOB]->join();
		delete test_job[TEST_ORCA_JOB];
		test_job[TEST_ORCA_JOB] = nullptr;
	}

    test_job[TEST_ORCA_JOB] = new boost::thread([weak_this = weak_this] {
        auto self = weak_this.lock();
		if (!self) return;
        self->start_test_url(TEST_ORCA_JOB, "Snapmaker Orca(GitHub)", "https://github.com/Snapmaker/OrcaSlicer");
    });
}

void NetworkTestDialog::start_test_bing_thread()
{
	if (m_in_testing[TEST_BING_JOB].load())
		return;

	if (test_job[TEST_BING_JOB] != nullptr && test_job[TEST_BING_JOB]->joinable()) {
		test_job[TEST_BING_JOB]->join();
		delete test_job[TEST_BING_JOB];
		test_job[TEST_BING_JOB] = nullptr;
	}

    test_job[TEST_BING_JOB] = new boost::thread([weak_this = weak_this] {
        auto self = weak_this.lock();
		if (!self) return;
        self->start_test_url(TEST_BING_JOB, "Bing", "http://www.bing.com");
    });
}

void NetworkTestDialog::start_test_login_api_thread()
{
    if (m_in_testing[TEST_LOGIN_API_JOB].load())
        return;

	if (test_job[TEST_LOGIN_API_JOB] != nullptr && test_job[TEST_LOGIN_API_JOB]->joinable()) {
		test_job[TEST_LOGIN_API_JOB]->join();
		delete test_job[TEST_LOGIN_API_JOB];
		test_job[TEST_LOGIN_API_JOB] = nullptr;
	}

	test_job[TEST_LOGIN_API_JOB] = new boost::thread([weak_this = weak_this] {
		auto self = weak_this.lock();
		if (!self) return;
		auto app_config = wxGetApp().app_config;
		std::string region = app_config->get("region");
		wxString login_api_url = (region == "Chinese Mainland") ? "https://id.snapmaker.cn" : "https://id.snapmaker.com";
		self->start_test_url(TEST_LOGIN_API_JOB, "Login API", login_api_url);
	});
}

void NetworkTestDialog::start_test_upload_api_thread()
{
    if (m_in_testing[TEST_UPLOAD_API_JOB].load())
        return;

	if (test_job[TEST_UPLOAD_API_JOB] != nullptr && test_job[TEST_UPLOAD_API_JOB]->joinable()) {
		test_job[TEST_UPLOAD_API_JOB]->join();
		delete test_job[TEST_UPLOAD_API_JOB];
		test_job[TEST_UPLOAD_API_JOB] = nullptr;
	}

	test_job[TEST_UPLOAD_API_JOB] = new boost::thread([weak_this = weak_this] {
		auto self = weak_this.lock();
		if (!self) return;
		auto app_config = wxGetApp().app_config;
		std::string region = app_config->get("region");
		wxString upload_api_url = (region == "Chinese Mainland") ? "https://public.resource.snapmaker.cn" : "https://public.resource.snapmaker.com";
		self->start_test_url(TEST_UPLOAD_API_JOB, "Upload API", upload_api_url);
	});
}

void NetworkTestDialog::on_close(wxCloseEvent& event)
{
	m_download_cancel = true;
	m_closing.store(true);
	cleanup_threads();
	event.Skip();
}


wxString NetworkTestDialog::get_studio_version()
{
	return wxString(Snapmaker_VERSION);
}

void NetworkTestDialog::set_default()
{
	for (int i = 0; i < TEST_JOB_MAX; i++) {
		test_job[i] = nullptr;
		m_in_testing[i].store(false);
	}

	m_sequence_job = nullptr;

	text_version_val->SetLabelText(get_studio_version());
	txt_sys_info_value->SetLabelText(get_os_info());
	txt_dns_info_value->SetLabelText(get_dns_info());
	text_link_val->SetLabelText(NA_STR);
	text_bing_val->SetLabelText(NA_STR);
	text_lan_mqtt_val->SetLabelText(NA_STR);
	text_cloud_mqtt_val->SetLabelText(NA_STR);
	text_login_api_val->SetLabelText(NA_STR);
	text_upload_api_val->SetLabelText(NA_STR);
	m_download_cancel = false;
	m_closing.store(false);
}


void NetworkTestDialog::on_dpi_changed(const wxRect &suggested_rect)
{
    ;
}

void NetworkTestDialog::update_status(int job_id, wxString info)
{
	// Early exit if dialog is closing - don't access any members
	if (m_closing.load()) return;

	// Use try-catch to protect against accessing destroyed dialog
	try {
		// Double check before creating event
		if (m_closing.load()) return;

		auto evt = new wxCommandEvent(EVT_UPDATE_RESULT, this->GetId());
		evt->SetString(info);
		evt->SetInt(job_id);

		// Triple check before queuing - race condition window is very small
		if (!m_closing.load()) {
			wxQueueEvent(this, evt);
		} else {
			delete evt;
		}
	} catch (...) {
		// Silently ignore if dialog was destroyed during operation
	}
}

void NetworkTestDialog::cleanup_threads()
{
	// Clean up test job threads
	for (int i = 0; i < TEST_JOB_MAX; i++) {
		if (test_job[i] != nullptr) {
			if (test_job[i]->joinable()) {
				// Try to join with longer timeout (1000ms) to reduce chance of detach
				// Threads should check m_closing and exit promptly
				if (!test_job[i]->try_join_for(boost::chrono::milliseconds(1000))) {
					// Thread didn't finish in time, detach it to avoid blocking
					// The thread will check m_closing and should exit safely
					test_job[i]->detach();
					BOOST_LOG_TRIVIAL(warning) << "Thread " << i << " didn't finish in time, detached";
				}
			}
			delete test_job[i];
			test_job[i] = nullptr;
		}
	}

	// Clean up sequence job thread
	if (m_sequence_job != nullptr) {
		if (m_sequence_job->joinable()) {
			// Try to join with longer timeout (1000ms)
			if (!m_sequence_job->try_join_for(boost::chrono::milliseconds(1000))) {
				// Thread didn't finish in time, detach it
				m_sequence_job->detach();
				BOOST_LOG_TRIVIAL(warning) << "Sequence job thread didn't finish in time, detached";
			}
		}
		delete m_sequence_job;
		m_sequence_job = nullptr;
	}
}


} // namespace GUI
} // namespace Slic3r