datatrace/source/interface.cpp

#define NOMINMAX
#ifndef UNICODE
#define UNICODE
#endif
#ifndef _UNICODE
#define _UNICODE
#endif

#include "pq_app.h"

#include "json.hpp"
#include "tinyxml2.h"

#include <windows.h>
#include <commctrl.h>
#include <commdlg.h>

#include <algorithm>
#include <cctype>
#include <cwctype>
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <map>
#include <memory>
#include <regex>
#include <set>
#include <sstream>
#include <unordered_map>
#include <unordered_set>

namespace {

using json = nlohmann::json;
namespace fs = std::filesystem;

enum ControlId {
    IDC_TAB = 900,
    IDC_PAGE_CONFIG,
    IDC_PAGE_LEDGER,
    IDC_PAGE_JSON,
    IDC_PAGE_PREVIEW,
    IDC_PAGE_XML_PREVIEW,
    IDC_FRONT_INST = 1001,
    IDC_FRONT_IP,
    IDC_TERMINAL_STATUS,
    IDC_MONITOR_STATUS,
    IDC_ICD_FLAG,
    IDC_WEB_DEVICE,
    IDC_WEB_ICD,
    IDC_WEB_FILEDOWNLOAD,
    IDC_XML_SAVE_DIR,
    IDC_PRODUCER_ACCESS_KEY,
    IDC_PRODUCER_SECRET_KEY,
    IDC_CONSUMER_ACCESS_KEY,
    IDC_CONSUMER_SECRET_KEY,
    IDC_PRODUCER,
    IDC_IPPORT,
    IDC_TOPIC_LOG,
    IDC_TAG_LOG,
    IDC_KEY_LOG,
    IDC_CONSUMER,
    IDC_CONSUMER_IPPORT,
    IDC_DATA_STAT_TOPIC,
    IDC_DATA_REALTIME_TOPIC,
    IDC_DATA_STAT_TAG,
    IDC_DATA_STAT_KEY,
    IDC_DATA_REALTIME_TAG,
    IDC_DATA_REALTIME_KEY,
    IDC_TRACE_TOPIC,
    IDC_TRACE_TAG,
    IDC_TRACE_KEY,
    IDC_XML_PATH,
    IDC_JSON_PATH,
    IDC_ORIGIN_PATHS,
    IDC_OUTPUT_PATH,
    IDC_FRONT_TYPE,
    IDC_TREE,
    IDC_DETAIL,
    IDC_LOG,
    IDC_JSON_TREE,
    IDC_JSON_DETAIL,
    IDC_JSON_MONITOR,
    IDC_PREVIEW_STATUS,
    IDC_PREVIEW_WORKBOOK,
    IDC_PREVIEW_SHEET,
    IDC_PREVIEW_FILTER,
    IDC_PREVIEW_PHASE,
    IDC_PREVIEW_ZOOM,
    IDC_PREVIEW_SEARCH,
    IDC_PREVIEW_SEARCH_BUTTON,
    IDC_PREVIEW_LIST,
    IDC_IMPORT_ICD,
    IDC_REVERSE_XML,
    IDC_XML_SEARCH,
    IDC_XML_SEARCH_BUTTON,
    IDC_XML_PREVIEW_EDIT,
    IDC_EXPORT_XML,
    IDC_PREVIEW_CELL_EDIT,
    IDC_GET_LEDGER = 2001,
    IDC_INIT_MQ,
    IDC_TRACE,
    IDC_PARSE,
    IDC_BROWSE_XML,
    IDC_BROWSE_JSON,
    IDC_ADD_ORIGIN
};

struct NodeRef {
    int device = -1;
    int monitor = -1;
};

struct JsonItem {
    std::string kind;
    std::string title;
    std::string body;
    std::string path;
    std::string dataType;
    std::string monitorId;
    std::string traceDir;
};

struct JsonNodeRef {
    int index = -1;
};

struct JsonMonitorChoice {
    std::string label;
    std::string traceDir;
    int device = -1;
    int monitor = -1;
};

struct PreviewSheetRow {
    std::vector<std::string> cells;
    std::vector<std::string> originalCells;
    std::vector<std::string> cellStyles;
    std::string phase;
    int status = 0;
};

struct PreviewSheet {
    std::string name;
    std::vector<PreviewSheetRow> rows;
    size_t maxCols = 0;
};

struct PreviewWorkbookChoice {
    std::string label;
    std::string path;
};

struct AppState {
    HINSTANCE inst = nullptr;
    HWND hwnd = nullptr;
    HWND tab = nullptr;
    HWND pageConfig = nullptr;
    HWND pageLedger = nullptr;
    HWND pageJson = nullptr;
    HWND pagePreview = nullptr;
    HWND pageXmlPreview = nullptr;
    HWND tree = nullptr;
    HWND detail = nullptr;
    HWND log = nullptr;
    HWND jsonTree = nullptr;
    HWND jsonDetail = nullptr;
    HWND jsonMonitor = nullptr;
    HWND previewStatus = nullptr;
    HWND previewWorkbook = nullptr;
    HWND previewSheet = nullptr;
    HWND previewFilter = nullptr;
    HWND previewPhase = nullptr;
    HWND previewZoom = nullptr;
    HWND previewSearch = nullptr;
    HWND previewList = nullptr;
    HWND importIcd = nullptr;
    HWND reverseXml = nullptr;
    HWND xmlSearch = nullptr;
    HWND xmlPreview = nullptr;
    HWND exportXml = nullptr;
    HWND previewEdit = nullptr;
    HWND busyPopup = nullptr;
    HWND frontType = nullptr;
    HFONT font = nullptr;
    HFONT previewFont = nullptr;
    HFONT xmlFont = nullptr;
    bool ownsFont = false;
    std::vector<PqLedgerDevice> devices;
    std::vector<std::unique_ptr<NodeRef>> refs;
    std::vector<JsonItem> jsonItems;
    std::vector<std::unique_ptr<JsonNodeRef>> jsonRefs;
    std::vector<JsonMonitorChoice> jsonMonitorChoices;
    std::vector<PreviewWorkbookChoice> previewWorkbooks;
    std::vector<PreviewSheet> previewSheets;
    std::string activeTraceDir;
    std::string activePreviewWorkbook;
    std::string pendingJsonMonitorTraceDir;
    std::string generatedXmlText;
    std::string generatedXmlSourcePath;
    std::string previewSearchText;
    std::string xmlSearchText;
    std::string xmlSearchLastText;
    size_t xmlSearchNextPos = 0;
    bool autoPreviewEnabled = false;
    bool jsonMonitorRefreshing = false;
    bool jsonMonitorRefreshPending = false;
    bool reverseXmlDirty = true;
    bool autoParseBusy = false;
    int activePreviewSheet = 0;
    int previewZoomPercent = 100;
    int previewStatusFilter = -1;
    std::string previewPhaseFilter;
    int editPreviewRow = -1;
    int editPreviewCol = -1;
    int editPreviewTopModelRow = -1;
    int editPreviewHorzPos = 0;
    int selectedDevice = -1;
    int selectedMonitor = -1;
    int selectedJson = -1;
};

AppState* g_app = nullptr;
constexpr UINT WM_PQ_MQ_EVENT = WM_APP + 101;
constexpr UINT WM_PQ_START_PREVIEW_EDIT = WM_APP + 102;

std::wstring u8w(const std::string& s) {
    if (s.empty()) return L"";
    int n = MultiByteToWideChar(CP_UTF8, 0, s.data(), (int)s.size(), nullptr, 0);
    std::wstring out(n, L'\0');
    MultiByteToWideChar(CP_UTF8, 0, s.data(), (int)s.size(), out.data(), n);
    return out;
}

std::string w8(const std::wstring& s) {
    if (s.empty()) return "";
    int n = WideCharToMultiByte(CP_UTF8, 0, s.data(), (int)s.size(), nullptr, 0, nullptr, nullptr);
    std::string out(n, '\0');
    WideCharToMultiByte(CP_UTF8, 0, s.data(), (int)s.size(), out.data(), n, nullptr, nullptr);
    return out;
}

struct FindCtx {
    int id;
    HWND found;
};

BOOL CALLBACK enumFindControl(HWND child, LPARAM lp) {
    auto* ctx = reinterpret_cast<FindCtx*>(lp);
    if (GetDlgCtrlID(child) == ctx->id) {
        ctx->found = child;
        return FALSE;
    }
    return TRUE;
}

HWND findControl(HWND root, int id) {
    HWND direct = GetDlgItem(root, id);
    if (direct) return direct;
    FindCtx ctx{id, nullptr};
    EnumChildWindows(root, enumFindControl, reinterpret_cast<LPARAM>(&ctx));
    return ctx.found;
}

std::string getText(HWND hwnd, int id) {
    HWND h = findControl(hwnd, id);
    if (!h) return "";
    int len = GetWindowTextLengthW(h);
    std::wstring text(len + 1, L'\0');
    GetWindowTextW(h, text.data(), len + 1);
    text.resize(len);
    return w8(text);
}

void setText(HWND hwnd, int id, const std::string& value) {
    HWND h = findControl(hwnd, id);
    if (h) SetWindowTextW(h, u8w(value).c_str());
}

void applyFont(AppState& app, HWND ctl) {
    SendMessageW(ctl, WM_SETFONT, (WPARAM)app.font, TRUE);
}

void updatePreviewFont(AppState& app) {
    if (app.previewFont) {
        DeleteObject(app.previewFont);
        app.previewFont = nullptr;
    }
    int height = -std::max(10, app.previewZoomPercent * 16 / 100);
    app.previewFont = CreateFontW(height, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE,
                                  DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                                  CLEARTYPE_QUALITY, DEFAULT_PITCH | FF_SWISS, L"Microsoft YaHei UI");
    if (app.previewList) {
        SendMessageW(app.previewList, WM_SETFONT, (WPARAM)(app.previewFont ? app.previewFont : app.font), TRUE);
        InvalidateRect(app.previewList, nullptr, TRUE);
    }
}

LRESULT CALLBACK panelProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
    if ((msg == WM_COMMAND || msg == WM_NOTIFY) && g_app && g_app->hwnd) {
        return SendMessageW(g_app->hwnd, msg, wp, lp);
    }
    return DefWindowProcW(hwnd, msg, wp, lp);
}

HWND addLabel(AppState& app, HWND parent, const wchar_t* text, int x, int y, int w, int h) {
    HWND ctl = CreateWindowExW(0, L"STATIC", text, WS_CHILD | WS_VISIBLE | SS_LEFT | SS_NOPREFIX,
                               x, y + 4, w, h, parent, nullptr, app.inst, nullptr);
    applyFont(app, ctl);
    return ctl;
}

HWND addEdit(AppState& app, HWND parent, int id, const std::string& text, int x, int y, int w, int h) {
    h = std::max(h, 28);
    HWND ctl = CreateWindowExW(WS_EX_CLIENTEDGE, L"EDIT", u8w(text).c_str(),
                               WS_CHILD | WS_VISIBLE | WS_TABSTOP | ES_AUTOHSCROLL | ES_NOHIDESEL,
                               x, y, w, h, parent, (HMENU)(INT_PTR)id, app.inst, nullptr);
    applyFont(app, ctl);
    SendMessageW(ctl, EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELPARAM(5, 5));
    return ctl;
}

HWND addMemo(AppState& app, HWND parent, int id, int x, int y, int w, int h) {
    HWND ctl = CreateWindowExW(WS_EX_CLIENTEDGE, L"EDIT", L"",
                               WS_CHILD | WS_VISIBLE | WS_TABSTOP | ES_MULTILINE |
                                   ES_AUTOVSCROLL | WS_VSCROLL,
                               x, y, w, h, parent, (HMENU)(INT_PTR)id, app.inst, nullptr);
    applyFont(app, ctl);
    return ctl;
}

HWND addButton(AppState& app, HWND parent, int id, const wchar_t* text, int x, int y, int w, int h) {
    HWND ctl = CreateWindowExW(0, L"BUTTON", text, WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON,
                               x, y, w, h, parent, (HMENU)(INT_PTR)id, app.inst, nullptr);
    applyFont(app, ctl);
    return ctl;
}

HWND addGroup(AppState& app, HWND parent, const wchar_t* text, int x, int y, int w, int h) {
    HWND ctl = CreateWindowExW(0, L"BUTTON", text, WS_CHILD | WS_VISIBLE | BS_GROUPBOX,
                               x, y, w, h, parent, nullptr, app.inst, nullptr);
    applyFont(app, ctl);
    return ctl;
}

void addLabeledEdit(AppState& app, HWND parent, const wchar_t* label, int id, const std::string& value,
                    int x, int y, int labelW, int editW) {
    addLabel(app, parent, label, x, y, labelW, 22);
    addEdit(app, parent, id, value, x + labelW, y, editW, 28);
}

void appendLogW(AppState& app, const std::wstring& line) {
    if (!app.log) return;
    std::wstring text = line + L"\r\n";
    int len = GetWindowTextLengthW(app.log);
    SendMessageW(app.log, EM_SETSEL, len, len);
    SendMessageW(app.log, EM_REPLACESEL, FALSE, (LPARAM)text.c_str());
}

void appendLog(AppState& app, const std::string& line) {
    appendLogW(app, u8w(line));
}

std::string paddedLineNumber(int line, int width) {
    std::string text = std::to_string(line);
    if ((int)text.size() < width) text.insert(text.begin(), width - text.size(), ' ');
    return text;
}

std::string xmlPreviewDisplayText(const std::string& xml) {
    if (xml.empty()) return "";
    int lines = 1;
    for (char c : xml) {
        if (c == '\n') ++lines;
    }
    int width = std::max(3, (int)std::to_string(lines).size());
    std::ostringstream out;
    std::stringstream ss(xml);
    std::string line;
    int lineNo = 1;
    while (std::getline(ss, line)) {
        if (!line.empty() && line.back() == '\r') line.pop_back();
        out << paddedLineNumber(lineNo++, width) << "  " << line << "\r\n";
    }
    return out.str();
}

bool highlightXmlSearch(AppState& app, bool focusPreview = false, bool findNext = false) {
    if (!app.xmlPreview) return false;
    std::string search = app.xmlSearchText;
    auto isSpace = [](unsigned char c) { return std::isspace(c) != 0; };
    search.erase(search.begin(), std::find_if(search.begin(), search.end(), [&](char c) {
        return !isSpace(static_cast<unsigned char>(c));
    }));
    search.erase(std::find_if(search.rbegin(), search.rend(), [&](char c) {
        return !isSpace(static_cast<unsigned char>(c));
    }).base(), search.end());
    if (search.empty()) return false;
    std::wstring display = u8w(xmlPreviewDisplayText(app.generatedXmlText));
    std::wstring needle = u8w(search);
    std::wstring haystack = display;
    std::transform(haystack.begin(), haystack.end(), haystack.begin(),
                   [](wchar_t c) { return (wchar_t)std::towlower(c); });
    std::transform(needle.begin(), needle.end(), needle.begin(),
                   [](wchar_t c) { return (wchar_t)std::towlower(c); });
    size_t start = 0;
    if (findNext && app.xmlSearchLastText == search) {
        start = std::min(app.xmlSearchNextPos, haystack.size());
    }
    size_t pos = haystack.find(needle, start);
    if (pos == std::wstring::npos && findNext && start > 0) {
        pos = haystack.find(needle, 0);
    }
    if (pos == std::wstring::npos) return false;
    if (findNext) {
        app.xmlSearchLastText = search;
        app.xmlSearchNextPos = pos + needle.size();
    }
    if (focusPreview) SetFocus(app.xmlPreview);
    SendMessageW(app.xmlPreview, EM_SETSEL, (WPARAM)pos, (LPARAM)(pos + needle.size()));
    SendMessageW(app.xmlPreview, EM_SCROLLCARET, 0, 0);
    if (focusPreview) SetFocus(app.xmlPreview);
    return true;
}

void updateXmlPreviewText(AppState& app) {
    if (!app.xmlPreview) return;
    SetWindowTextW(app.xmlPreview, u8w(xmlPreviewDisplayText(app.generatedXmlText)).c_str());
    highlightXmlSearch(app, false, false);
}

void showBusyPopup(AppState& app, const wchar_t* message) {
    if (!app.hwnd) return;
    if (app.busyPopup && IsWindow(app.busyPopup)) {
        SetWindowTextW(app.busyPopup, message);
    } else {
        RECT owner{};
        GetWindowRect(app.hwnd, &owner);
        int w = 380;
        int h = 90;
        int x = owner.left + std::max(0L, (owner.right - owner.left - w) / 2);
        int y = owner.top + std::max(0L, (owner.bottom - owner.top - h) / 2);
        app.busyPopup = CreateWindowExW(WS_EX_TOPMOST | WS_EX_TOOLWINDOW,
                                        L"STATIC",
                                        message,
                                        WS_POPUP | WS_BORDER | SS_CENTER | SS_CENTERIMAGE,
                                        x, y, w, h,
                                        app.hwnd,
                                        nullptr,
                                        app.inst,
                                        nullptr);
        if (app.busyPopup) applyFont(app, app.busyPopup);
    }
    if (app.busyPopup) {
        ShowWindow(app.busyPopup, SW_SHOWNOACTIVATE);
        UpdateWindow(app.busyPopup);
    }
}

void hideBusyPopup(AppState& app) {
    if (app.busyPopup && IsWindow(app.busyPopup)) {
        DestroyWindow(app.busyPopup);
    }
    app.busyPopup = nullptr;
}

struct BusyPopupGuard {
    AppState& app;
    bool active;

    BusyPopupGuard(AppState& state, bool show, const wchar_t* message)
        : app(state), active(show) {
        if (active) {
            app.autoParseBusy = true;
            showBusyPopup(app, message);
        }
    }

    ~BusyPopupGuard() {
        if (active) {
            hideBusyPopup(app);
            app.autoParseBusy = false;
        }
    }
};

std::string readAllText(const fs::path& path) {
    std::ifstream ifs(path, std::ios::binary);
    if (!ifs) return "";
    std::ostringstream ss;
    ss << ifs.rdbuf();
    return ss.str();
}

std::string truncateText(std::string text, size_t limit = 260) {
    if (text.size() <= limit) return text;
    return text.substr(0, limit) + "...";
}

std::string trimAscii(std::string s) {
    auto isSpace = [](unsigned char c) { return std::isspace(c) != 0; };
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [&](char c) { return !isSpace(static_cast<unsigned char>(c)); }));
    s.erase(std::find_if(s.rbegin(), s.rend(), [&](char c) { return !isSpace(static_cast<unsigned char>(c)); }).base(), s.end());
    return s;
}

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

bool textContainsFilter(const std::string& text, const std::string& filter) {
    if (filter.empty()) return true;
    return lowerAsciiCopy(text).find(lowerAsciiCopy(filter)) != std::string::npos;
}

std::vector<std::string> splitPathList(std::string text) {
    for (char& c : text) {
        if (c == ';' || c == '\r' || c == '\n') c = '\n';
    }
    std::vector<std::string> paths;
    std::stringstream ss(text);
    std::string part;
    while (std::getline(ss, part, '\n')) {
        part = trimAscii(part);
        if (!part.empty()) paths.push_back(part);
    }
    return paths;
}

std::string joinPaths(const std::vector<std::string>& paths);
std::vector<std::string> collectOriginFiles(const fs::path& dir);
std::vector<std::string> collectJsonDataFiles(const fs::path& dir);

std::string selectedFrontTypeFromWindow(HWND hwnd) {
    HWND combo = findControl(hwnd, IDC_FRONT_TYPE);
    if (!combo) return "cfg_stat_data";
    int idx = (int)SendMessageW(combo, CB_GETCURSEL, 0, 0);
    wchar_t buf[128]{};
    SendMessageW(combo, CB_GETLBTEXT, idx < 0 ? 0 : idx, (LPARAM)buf);
    std::string value = w8(buf);
    return value.empty() ? "cfg_stat_data" : value;
}

PqToolConfig readConfig(HWND hwnd) {
    PqToolConfig cfg = pqDefaultConfig();
    cfg.frontInst = getText(hwnd, IDC_FRONT_INST);
    cfg.frontIp = getText(hwnd, IDC_FRONT_IP);
    cfg.terminalStatus = getText(hwnd, IDC_TERMINAL_STATUS);
    cfg.monitorStatus = getText(hwnd, IDC_MONITOR_STATUS);
    cfg.icdFlag = getText(hwnd, IDC_ICD_FLAG);
    cfg.webDevice = getText(hwnd, IDC_WEB_DEVICE);
    cfg.webIcd = getText(hwnd, IDC_WEB_ICD);
    cfg.webFiledownload = getText(hwnd, IDC_WEB_FILEDOWNLOAD);
    cfg.xmlSaveDir = getText(hwnd, IDC_XML_SAVE_DIR);
    cfg.producer = getText(hwnd, IDC_PRODUCER);
    cfg.ipport = getText(hwnd, IDC_IPPORT);
    cfg.producerAccessKey = getText(hwnd, IDC_PRODUCER_ACCESS_KEY);
    cfg.producerSecretKey = getText(hwnd, IDC_PRODUCER_SECRET_KEY);
    cfg.topicLOG = getText(hwnd, IDC_TOPIC_LOG);
    cfg.tagLOG = getText(hwnd, IDC_TAG_LOG);
    cfg.keyLOG = getText(hwnd, IDC_KEY_LOG);
    cfg.consumer = getText(hwnd, IDC_CONSUMER);
    cfg.consumerIpport = getText(hwnd, IDC_CONSUMER_IPPORT);
    cfg.consumerAccessKey = getText(hwnd, IDC_CONSUMER_ACCESS_KEY);
    cfg.consumerSecretKey = getText(hwnd, IDC_CONSUMER_SECRET_KEY);
    cfg.dataStatTopic = getText(hwnd, IDC_DATA_STAT_TOPIC);
    cfg.dataRealtimeTopic = getText(hwnd, IDC_DATA_REALTIME_TOPIC);
    cfg.dataStatTag = getText(hwnd, IDC_DATA_STAT_TAG);
    cfg.dataStatKey = getText(hwnd, IDC_DATA_STAT_KEY);
    cfg.dataRealtimeTag = getText(hwnd, IDC_DATA_REALTIME_TAG);
    cfg.dataRealtimeKey = getText(hwnd, IDC_DATA_REALTIME_KEY);
    std::string frontType = selectedFrontTypeFromWindow(hwnd);
    if (frontType == "cfg_3s_data") {
        cfg.dataTopic = cfg.dataRealtimeTopic;
        cfg.dataTag = cfg.dataRealtimeTag;
        cfg.dataKey = cfg.dataRealtimeKey;
    } else {
        cfg.dataTopic = cfg.dataStatTopic;
        cfg.dataTag = cfg.dataStatTag;
        cfg.dataKey = cfg.dataStatKey;
    }
    cfg.traceTopic = getText(hwnd, IDC_TRACE_TOPIC);
    cfg.traceTag = getText(hwnd, IDC_TRACE_TAG);
    cfg.traceKey = getText(hwnd, IDC_TRACE_KEY);
    cfg.xmlPath = getText(hwnd, IDC_XML_PATH);
    cfg.jsonDataPath = getText(hwnd, IDC_JSON_PATH);
    cfg.jsonDataPaths = splitPathList(cfg.jsonDataPath);
    cfg.outputPath = getText(hwnd, IDC_OUTPUT_PATH);

    cfg.originPaths = splitPathList(getText(hwnd, IDC_ORIGIN_PATHS));
    return cfg;
}

int toInt(const std::string& s) {
    try {
        return s.empty() ? 0 : std::stoi(s);
    } catch (...) {
        return 0;
    }
}

NodeRef* makeRef(AppState& app, int device, int monitor) {
    auto ref = std::make_unique<NodeRef>();
    ref->device = device;
    ref->monitor = monitor;
    NodeRef* p = ref.get();
    app.refs.push_back(std::move(ref));
    return p;
}

JsonNodeRef* makeJsonRef(AppState& app, int index) {
    auto ref = std::make_unique<JsonNodeRef>();
    ref->index = index;
    JsonNodeRef* p = ref.get();
    app.jsonRefs.push_back(std::move(ref));
    return p;
}

HTREEITEM insertTreeItemRaw(HWND tree, HTREEITEM parent, const std::wstring& text, LPARAM ref) {
    TVINSERTSTRUCTW tv{};
    tv.hParent = parent;
    tv.hInsertAfter = TVI_LAST;
    tv.item.mask = TVIF_TEXT | TVIF_PARAM;
    tv.item.pszText = const_cast<wchar_t*>(text.c_str());
    tv.item.lParam = ref;
    return (HTREEITEM)SendMessageW(tree, TVM_INSERTITEMW, 0, (LPARAM)&tv);
}

HTREEITEM insertTreeItem(AppState& app, HTREEITEM parent, const std::wstring& text, NodeRef* ref) {
    return insertTreeItemRaw(app.tree, parent, text, (LPARAM)ref);
}

HTREEITEM insertJsonTreeItem(AppState& app, HTREEITEM parent, const std::wstring& text, JsonNodeRef* ref) {
    return insertTreeItemRaw(app.jsonTree, parent, text, (LPARAM)ref);
}

std::wstring deviceLabel(const PqLedgerDevice& d) {
    {
        std::wstring text = L"\x88C5\x7F6E ";
        text += u8w(d.name.empty() ? d.id : d.name);
        text += L"  id=" + u8w(d.id);
        text += L"  type=" + u8w(d.devType);
        return text;
    }
    std::wstring text = L"装置 ";
    text += u8w(d.name.empty() ? d.id : d.name);
    text += L"  id=" + u8w(d.id);
    text += L"  type=" + u8w(d.devType);
    return text;
}

std::wstring monitorLabel(const PqLedgerMonitor& m) {
    {
        std::wstring text = L"\x6D4B\x70B9 ";
        text += u8w(m.name.empty() ? m.id : m.name);
        text += L"  id=" + u8w(m.id);
        return text;
    }
    std::wstring text = L"测点 ";
    text += u8w(m.name.empty() ? m.id : m.name);
    text += L"  id=" + u8w(m.id);
    return text;
}

std::wstring processLabel(int processNo) {
    return L"\x8FDB\x7A0B " + std::to_wstring(processNo);
}

void populateTree(AppState& app) {
    TreeView_DeleteAllItems(app.tree);
    app.refs.clear();
    app.selectedDevice = -1;
    app.selectedMonitor = -1;

    int maxProcess = 0;
    for (const auto& d : app.devices) {
        maxProcess = std::max(maxProcess, toInt(d.processNo));
        maxProcess = std::max(maxProcess, toInt(d.maxProcessNum));
    }
    if (!app.devices.empty() && maxProcess < 2) maxProcess = 2;

    std::map<int, HTREEITEM> processNodes;
    for (int i = 1; i <= maxProcess; ++i) {
        processNodes[i] = insertTreeItem(app, TVI_ROOT, processLabel(i), makeRef(app, -1, -1));
    }

    for (size_t i = 0; i < app.devices.size(); ++i) {
        const auto& d = app.devices[i];
        int proc = toInt(d.processNo);
        if (proc <= 0) proc = 1;
        if (!processNodes.count(proc)) {
            processNodes[proc] = insertTreeItem(app, TVI_ROOT, processLabel(proc), makeRef(app, -1, -1));
        }
        HTREEITEM devItem = insertTreeItem(app, processNodes[proc], deviceLabel(d), makeRef(app, (int)i, -1));
        for (size_t j = 0; j < d.monitors.size(); ++j) {
            insertTreeItem(app, devItem, monitorLabel(d.monitors[j]), makeRef(app, (int)i, (int)j));
        }
        TreeView_Expand(app.tree, processNodes[proc], TVE_EXPAND);
        TreeView_Expand(app.tree, devItem, TVE_EXPAND);
    }
}

void appendFields(std::wstring& text, const std::vector<std::pair<std::string, std::string>>& fields) {
    for (const auto& kv : fields) {
        text += u8w(kv.first) + L": " + u8w(kv.second) + L"\r\n";
    }
}

void updateDetails(AppState& app) {
    {
        std::wstring text;
        if (app.selectedDevice >= 0 && app.selectedDevice < (int)app.devices.size()) {
            const auto& d = app.devices[app.selectedDevice];
            if (app.selectedMonitor >= 0 && app.selectedMonitor < (int)d.monitors.size()) {
                const auto& m = d.monitors[app.selectedMonitor];
                text += L"\x6D4B\x70B9\x53F0\x8D26\x4FE1\x606F\r\n";
                text += L"\x6240\x5C5E\x88C5\x7F6E: " + u8w(d.name) + L"\r\n";
                text += L"\x6240\x5C5E\x88C5\x7F6EID: " + u8w(d.id) + L"\r\n";
                text += L"\x6240\x5C5E\x8FDB\x7A0B\x53F7: " + u8w(d.processNo) + L"\r\n";
                text += L"------------------------------\r\n";
                if (!m.fields.empty()) appendFields(text, m.fields);
                else {
                    text += L"id: " + u8w(m.id) + L"\r\n";
                    text += L"name: " + u8w(m.name) + L"\r\n";
                    text += L"lineNo: " + u8w(m.lineNo) + L"\r\n";
                    text += L"voltageLevel: " + u8w(m.voltageLevel) + L"\r\n";
                    text += L"ptType: " + u8w(m.connectType) + L"\r\n";
                    text += L"status: " + u8w(m.status) + L"\r\n";
                }
            } else {
                text += L"\x88C5\x7F6E\x53F0\x8D26\x4FE1\x606F\r\n";
                if (!d.fields.empty()) appendFields(text, d.fields);
                else {
                    text += L"id: " + u8w(d.id) + L"\r\n";
                    text += L"name: " + u8w(d.name) + L"\r\n";
                    text += L"ip: " + u8w(d.ip) + L"\r\n";
                    text += L"status: " + u8w(d.status) + L"\r\n";
                    text += L"devType: " + u8w(d.devType) + L"\r\n";
                    text += L"processNo: " + u8w(d.processNo) + L"\r\n";
                    text += L"maxProcessNum: " + u8w(d.maxProcessNum) + L"\r\n";
                }
                text += L"monitorDataCount: " + std::to_wstring(d.monitors.size()) + L"\r\n";
            }
        } else {
            text = L"\x8BF7\x9009\x62E9\x5DE6\x4FA7\x6811\x4E2D\x7684\x88C5\x7F6E\x6216\x6D4B\x70B9\x3002\x70B9\x51FB\x88C5\x7F6E\x663E\x793A\x88C5\x7F6E\x53F0\x8D26\x4FE1\x606F\xFF0C\x70B9\x51FB\x6D4B\x70B9\x663E\x793A\x6D4B\x70B9\x53F0\x8D26\x4FE1\x606F\x3002";
        }
        SetWindowTextW(app.detail, text.c_str());
        return;
    }
    std::wstring text;
    if (app.selectedDevice >= 0 && app.selectedDevice < (int)app.devices.size()) {
        const auto& d = app.devices[app.selectedDevice];
        if (app.selectedMonitor >= 0 && app.selectedMonitor < (int)d.monitors.size()) {
            const auto& m = d.monitors[app.selectedMonitor];
            text += L"测点台账信息\r\n";
            text += L"所属装置: " + u8w(d.name) + L"\r\n";
            text += L"所属装置ID: " + u8w(d.id) + L"\r\n";
            text += L"所属进程号: " + u8w(d.processNo) + L"\r\n";
            text += L"------------------------------\r\n";
            if (!m.fields.empty()) appendFields(text, m.fields);
            else {
                text += L"id: " + u8w(m.id) + L"\r\n";
                text += L"name: " + u8w(m.name) + L"\r\n";
                text += L"lineNo: " + u8w(m.lineNo) + L"\r\n";
                text += L"voltageLevel: " + u8w(m.voltageLevel) + L"\r\n";
                text += L"ptType: " + u8w(m.connectType) + L"\r\n";
                text += L"status: " + u8w(m.status) + L"\r\n";
            }
        } else {
            text += L"装置台账信息\r\n";
            if (!d.fields.empty()) appendFields(text, d.fields);
            else {
                text += L"id: " + u8w(d.id) + L"\r\n";
                text += L"name: " + u8w(d.name) + L"\r\n";
                text += L"ip: " + u8w(d.ip) + L"\r\n";
                text += L"status: " + u8w(d.status) + L"\r\n";
                text += L"devType: " + u8w(d.devType) + L"\r\n";
                text += L"processNo: " + u8w(d.processNo) + L"\r\n";
                text += L"maxProcessNum: " + u8w(d.maxProcessNum) + L"\r\n";
            }
            text += L"monitorDataCount: " + std::to_wstring(d.monitors.size()) + L"\r\n";
        }
    } else {
        text = L"请选择左侧树中的装置或测点。点击装置显示装置台账信息，点击测点显示测点台账信息。";
    }
    SetWindowTextW(app.detail, text.c_str());
}

std::string prettyJsonText(const std::string& text) {
    try {
        return json::parse(text).dump(2);
    } catch (...) {
        return text;
    }
}

std::string jsonScalarString(const json& value) {
    if (value.is_string()) return value.get<std::string>();
    if (value.is_number_integer()) return std::to_string(value.get<long long>());
    if (value.is_number_unsigned()) return std::to_string(value.get<unsigned long long>());
    if (value.is_number_float()) {
        std::ostringstream oss;
        oss << value.get<double>();
        return oss.str();
    }
    if (value.is_boolean()) return value.get<bool>() ? "true" : "false";
    return value.dump();
}

std::string normalizeDataTypeText(std::string dataType) {
    dataType.erase(std::remove_if(dataType.begin(), dataType.end(),
                                  [](unsigned char c) { return std::isspace(c) != 0; }),
                   dataType.end());
    if (dataType.size() == 1 && std::isdigit(static_cast<unsigned char>(dataType[0]))) {
        dataType = "0" + dataType;
    }
    return dataType;
}

bool findDataTypeInJson(const json& value, std::string& out) {
    if (value.is_object()) {
        auto it = value.find("DATA_TYPE");
        if (it != value.end()) {
            out = normalizeDataTypeText(jsonScalarString(*it));
            return true;
        }
        for (auto iter = value.begin(); iter != value.end(); ++iter) {
            if (findDataTypeInJson(iter.value(), out)) return true;
        }
    } else if (value.is_array()) {
        for (const auto& item : value) {
            if (findDataTypeInJson(item, out)) return true;
        }
    }
    return false;
}

std::string dataTypeFromJsonText(const std::string& text) {
    try {
        json root = json::parse(text);
        std::string dataType;
        if (findDataTypeInJson(root, dataType)) return dataType;
    } catch (...) {
    }
    return "";
}

void appendOriginPathToUi(AppState& app, const std::string& path) {
    if (path.empty()) return;
    std::vector<std::string> paths = splitPathList(getText(app.hwnd, IDC_ORIGIN_PATHS));
    if (std::find(paths.begin(), paths.end(), path) == paths.end()) {
        paths.push_back(path);
        setText(app.hwnd, IDC_ORIGIN_PATHS, joinPaths(paths));
    }
}

void appendJsonPathToUi(AppState& app, const std::string& path) {
    if (path.empty()) return;
    std::vector<std::string> paths = splitPathList(getText(app.hwnd, IDC_JSON_PATH));
    if (std::find(paths.begin(), paths.end(), path) == paths.end()) {
        paths.push_back(path);
        setText(app.hwnd, IDC_JSON_PATH, joinPaths(paths));
    }
}

std::string normalizedPathPrefix(std::string path) {
    try {
        path = fs::absolute(fs::u8path(path)).lexically_normal().u8string();
    } catch (...) {
    }
    for (char& ch : path) {
        if (ch == '/') ch = '\\';
    }
    return path;
}

bool pathIsUnderDir(const std::string& filePath, const std::string& dirPath) {
    if (filePath.empty() || dirPath.empty()) return true;
    std::string file = normalizedPathPrefix(filePath);
    std::string dir = normalizedPathPrefix(dirPath);
    if (file == dir) return true;
    if (!dir.empty() && dir.back() != '\\') dir += '\\';
    return file.rfind(dir, 0) == 0;
}

std::string traceDirFromPath(const std::string& path) {
    if (path.empty()) return "";
    try {
        return fs::u8path(path).parent_path().u8string();
    } catch (...) {
        return "";
    }
}

std::string eventTraceDir(const PqMqEvent& ev) {
    if (!ev.traceDir.empty()) return ev.traceDir;
    return traceDirFromPath(ev.path);
}

bool sameTraceDir(const std::string& a, const std::string& b) {
    if (a.empty() || b.empty()) return false;
    return normalizedPathPrefix(a) == normalizedPathPrefix(b);
}

bool jsonItemVisible(const AppState& app, const JsonItem& item) {
    if (app.activeTraceDir.empty()) return true;
    if (!item.traceDir.empty() && sameTraceDir(item.traceDir, app.activeTraceDir)) return true;
    return pathIsUnderDir(item.path, app.activeTraceDir);
}

int latestVisibleJsonIndex(const AppState& app) {
    for (int i = (int)app.jsonItems.size() - 1; i >= 0; --i) {
        if (jsonItemVisible(app, app.jsonItems[i])) return i;
    }
    return -1;
}

void refreshTraceInputsFromDisk(AppState& app, const std::string& traceDir) {
    if (traceDir.empty() || !app.hwnd || !sameTraceDir(traceDir, app.activeTraceDir)) return;
    fs::path dir = fs::u8path(traceDir);
    std::vector<std::string> jsonPaths = collectJsonDataFiles(dir);
    std::vector<std::string> originPaths = collectOriginFiles(dir);
    setText(app.hwnd, IDC_JSON_PATH, joinPaths(jsonPaths));
    setText(app.hwnd, IDC_ORIGIN_PATHS, joinPaths(originPaths));
}

void refreshTraceInputsFromDisk(AppState& app) {
    refreshTraceInputsFromDisk(app, app.activeTraceDir);
}

void rebuildJsonTree(AppState& app);
void updateJsonDetail(AppState& app);
void refreshPreviewFromWorkbook(AppState& app, const std::string& workbookPath);
void refreshPreviewWorkbookChoices(AppState& app, const std::string& selectedPath);
void autoParseAndRefresh(AppState& app, const char* reason);
void autoParseTraceDir(AppState& app, const std::string& traceDir, const char* reason);
void refreshJsonMonitorChoices(AppState& app, const std::string& selectedTraceDir);
void selectJsonMonitorChoice(AppState& app, int index);
std::string generateReverseXml(AppState& app, bool showMessage);

std::string previewWorkbookLabel(const fs::path& workbook, const PqToolConfig& cfg) {
    std::error_code ec;
    fs::path root = fs::u8path(cfg.traceRootDir.empty() ? "runtime\\trace_data" : cfg.traceRootDir);
    fs::path parent = workbook.parent_path();
    std::string monitorFolder = parent.filename().u8string();
    if (monitorFolder.rfind("monitor_", 0) == 0) {
        return truncateText(monitorFolder.substr(8), 90);
    }
    fs::path rel = fs::relative(parent, root, ec);
    if (!ec && !rel.empty() && rel.u8string().find("..") != 0) return rel.u8string();
    return parent.empty() ? workbook.filename().u8string() : parent.u8string();
}

void addPreviewWorkbookChoice(std::vector<PreviewWorkbookChoice>& choices,
                              std::unordered_set<std::string>& seen,
                              const fs::path& workbook,
                              const PqToolConfig& cfg) {
    if (workbook.empty() || !fs::exists(workbook)) return;
    std::string key = normalizedPathPrefix(workbook.u8string());
    if (!seen.insert(key).second) return;
    choices.push_back({previewWorkbookLabel(workbook, cfg), workbook.u8string()});
}

void refreshPreviewWorkbookChoices(AppState& app, const std::string& selectedPath) {
    if (!app.previewWorkbook || !app.hwnd) return;
    PqToolConfig cfg = readConfig(app.hwnd);
    std::vector<PreviewWorkbookChoice> choices;
    std::unordered_set<std::string> seen;

    if (!selectedPath.empty()) addPreviewWorkbookChoice(choices, seen, fs::u8path(selectedPath), cfg);
    if (!cfg.outputPath.empty()) addPreviewWorkbookChoice(choices, seen, fs::u8path(cfg.outputPath), cfg);

    fs::path root = fs::u8path(cfg.traceRootDir.empty() ? "runtime\\trace_data" : cfg.traceRootDir);
    std::error_code ec;
    if (fs::exists(root, ec)) {
        for (fs::recursive_directory_iterator it(root, fs::directory_options::skip_permission_denied, ec), end;
             it != end && !ec;
             it.increment(ec)) {
            if (!it->is_regular_file(ec)) continue;
            if (it->path().filename() == "final_sorted.xls") {
                addPreviewWorkbookChoice(choices, seen, it->path(), cfg);
            }
        }
    }

    std::string selectedKey = selectedPath.empty() ? "" : normalizedPathPrefix(selectedPath);
    int selectedIndex = -1;
    SendMessageW(app.previewWorkbook, CB_RESETCONTENT, 0, 0);
    for (size_t i = 0; i < choices.size(); ++i) {
        SendMessageW(app.previewWorkbook, CB_ADDSTRING, 0, (LPARAM)u8w(choices[i].label).c_str());
        if (!selectedKey.empty() && normalizedPathPrefix(choices[i].path) == selectedKey) selectedIndex = (int)i;
    }
    app.previewWorkbooks = std::move(choices);
    if (selectedIndex < 0 && !app.previewWorkbooks.empty()) selectedIndex = 0;
    if (selectedIndex >= 0) SendMessageW(app.previewWorkbook, CB_SETCURSEL, selectedIndex, 0);
}

void resetJsonSession(AppState& app, const std::string& traceDir) {
    app.activeTraceDir = traceDir;
    app.jsonItems.erase(std::remove_if(app.jsonItems.begin(), app.jsonItems.end(),
                                       [&](const JsonItem& item) {
                                           if (!item.traceDir.empty() && sameTraceDir(item.traceDir, traceDir)) return true;
                                           return !item.path.empty() && pathIsUnderDir(item.path, traceDir);
                                       }),
                        app.jsonItems.end());
    app.jsonRefs.clear();
    app.selectedJson = -1;
    app.activePreviewSheet = 0;
    app.previewStatusFilter = -1;
    app.activePreviewWorkbook.clear();
    app.previewWorkbooks.clear();
    if (app.hwnd) {
        setText(app.hwnd, IDC_JSON_PATH, "");
        setText(app.hwnd, IDC_ORIGIN_PATHS, "");
    }
    refreshJsonMonitorChoices(app, traceDir);
    rebuildJsonTree(app);
    updateJsonDetail(app);
    app.previewSheets.clear();
    if (app.previewWorkbook) SendMessageW(app.previewWorkbook, CB_RESETCONTENT, 0, 0);
    if (app.previewSheet) SendMessageW(app.previewSheet, CB_RESETCONTENT, 0, 0);
    if (app.previewFilter) SendMessageW(app.previewFilter, CB_SETCURSEL, 0, 0);
    if (app.previewPhase) SendMessageW(app.previewPhase, CB_SETCURSEL, 0, 0);
    if (app.previewList) ListView_DeleteAllItems(app.previewList);
    if (app.previewStatus) SetWindowTextW(app.previewStatus, L"\x5C1A\x672A\x5F00\x59CB\x6570\x636E\x8FFD\x8E2A");
}

std::wstring jsonGroupTitle(const std::string& kind) {
    if (kind == "sent") return L"\x6784\x9020\x548C\x53D1\x9001\x7684JSON";
    if (kind == "data") return L"\x6536\x5230\x7684" L"DATATopic JSON";
    return L"TraceTopic\x6536\x5230\x7684JSON\x5217\x8868";
}

void updateJsonDetail(AppState& app) {
    std::wstring text;
    if (app.selectedJson >= 0 && app.selectedJson < (int)app.jsonItems.size() &&
        jsonItemVisible(app, app.jsonItems[app.selectedJson])) {
        const auto& item = app.jsonItems[app.selectedJson];
        text += L"title: " + u8w(item.title) + L"\r\n";
        text += L"type: " + u8w(item.kind) + L"\r\n";
        if (!item.monitorId.empty()) text += L"monitor: " + u8w(item.monitorId) + L"\r\n";
        if (!item.path.empty()) text += L"path: " + u8w(item.path) + L"\r\n";
        text += L"------------------------------\r\n";
        text += u8w(prettyJsonText(item.body));
    } else {
        text = L"\x8BF7\x5728\x5DE6\x4FA7\x9009\x62E9JSON\x8BB0\x5F55\x3002";
    }
    if (app.jsonDetail) SetWindowTextW(app.jsonDetail, text.c_str());
}

void rebuildJsonTree(AppState& app) {
    if (!app.jsonTree) return;
    TreeView_DeleteAllItems(app.jsonTree);
    app.jsonRefs.clear();
    if (app.selectedJson < 0 || app.selectedJson >= (int)app.jsonItems.size() ||
        !jsonItemVisible(app, app.jsonItems[app.selectedJson])) {
        app.selectedJson = latestVisibleJsonIndex(app);
    }

    HTREEITEM sentRoot = insertJsonTreeItem(app, TVI_ROOT, jsonGroupTitle("sent"), makeJsonRef(app, -1));
    HTREEITEM dataRoot = insertJsonTreeItem(app, TVI_ROOT, jsonGroupTitle("data"), makeJsonRef(app, -1));
    HTREEITEM traceRoot = insertJsonTreeItem(app, TVI_ROOT, jsonGroupTitle("trace"), makeJsonRef(app, -1));
    HTREEITEM selectedItem = nullptr;

    for (size_t i = 0; i < app.jsonItems.size(); ++i) {
        const auto& item = app.jsonItems[i];
        if (!jsonItemVisible(app, item)) continue;
        HTREEITEM parent = item.kind == "sent" ? sentRoot : item.kind == "data" ? dataRoot : traceRoot;
        HTREEITEM h = insertJsonTreeItem(app, parent, u8w(item.title), makeJsonRef(app, (int)i));
        if ((int)i == app.selectedJson) selectedItem = h;
    }
    TreeView_Expand(app.jsonTree, sentRoot, TVE_EXPAND);
    TreeView_Expand(app.jsonTree, dataRoot, TVE_EXPAND);
    TreeView_Expand(app.jsonTree, traceRoot, TVE_EXPAND);
    if (selectedItem) TreeView_SelectItem(app.jsonTree, selectedItem);
}

void addJsonEvent(AppState& app, const PqMqEvent& ev) {
    JsonItem item{ev.kind, ev.title, ev.body, ev.path, "", ev.monitorId, eventTraceDir(ev)};
    if (item.kind.empty()) item.kind = "trace";
    if (item.title.empty()) item.title = item.kind;
    if (item.kind == "data") {
        item.dataType = dataTypeFromJsonText(item.body);
        if (item.dataType.empty()) item.dataType = "unknown";
        for (size_t i = 0; i < app.jsonItems.size(); ++i) {
            auto& existing = app.jsonItems[i];
            if (existing.kind == "data" &&
                existing.dataType == item.dataType &&
                sameTraceDir(existing.traceDir, item.traceDir)) {
                existing = item;
                existing.title += " DATA_TYPE=" + existing.dataType;
                if (jsonItemVisible(app, existing)) app.selectedJson = (int)i;
                if (app.autoPreviewEnabled) {
                    refreshTraceInputsFromDisk(app, item.traceDir);
                    autoParseTraceDir(app, item.traceDir, "data");
                }
                refreshJsonMonitorChoices(app, app.activeTraceDir);
                rebuildJsonTree(app);
                updateJsonDetail(app);
                return;
            }
        }
        item.title += " DATA_TYPE=" + item.dataType;
    }
    app.jsonItems.push_back(std::move(item));
    JsonItem& stored = app.jsonItems.back();
    if (jsonItemVisible(app, stored)) app.selectedJson = (int)app.jsonItems.size() - 1;
    refreshJsonMonitorChoices(app, app.activeTraceDir.empty() ? stored.traceDir : app.activeTraceDir);
    rebuildJsonTree(app);
    updateJsonDetail(app);
    if (app.autoPreviewEnabled && (stored.kind == "data" || stored.kind == "trace")) {
        refreshTraceInputsFromDisk(app, stored.traceDir);
        autoParseTraceDir(app, stored.traceDir, stored.kind.c_str());
    }
}

std::string attrValue(const tinyxml2::XMLElement* element, const char* name) {
    if (!element) return "";
    const char* value = element->Attribute(name);
    return value ? value : "";
}

std::string cellText(const tinyxml2::XMLElement* cell) {
    if (!cell) return "";
    const tinyxml2::XMLElement* data = cell->FirstChildElement("Data");
    if (!data) return "";
    const char* text = data->GetText();
    return text ? text : "";
}

std::string compactCells(const std::vector<std::string>& cells, size_t start) {
    size_t end = cells.size();
    while (end > start && cells[end - 1].empty()) --end;
    std::string out;
    for (size_t i = start; i < end; ++i) {
        if (!out.empty()) out += ",";
        out += cells[i];
    }
    return truncateText(out);
}

int previewStatusFromStyle(const std::string& style) {
    if (style == "MatchGreen") return 1;
    if (style == "MatchOrange") return 2;
    if (style == "MatchRed") return 3;
    if (style == "Head") return 4;
    if (style == "Section") return 5;
    if (style == "Sub") return 6;
    return 0;
}

std::vector<std::string> rowCells(const tinyxml2::XMLElement* row,
                                  std::string& style,
                                  std::vector<std::string>* cellStyles = nullptr) {
    std::vector<std::string> cells(64);
    std::vector<std::string> styles(64);
    int col = 1;
    for (const tinyxml2::XMLElement* cell = row ? row->FirstChildElement("Cell") : nullptr;
         cell;
         cell = cell->NextSiblingElement("Cell")) {
        const char* indexAttr = cell->Attribute("ss:Index");
        if (indexAttr && *indexAttr) col = std::max(1, std::atoi(indexAttr));
        if ((int)cells.size() < col) {
            cells.resize(col);
            styles.resize(col);
        }
        cells[col - 1] = cellText(cell);
        std::string cellStyle = attrValue(cell, "ss:StyleID");
        styles[col - 1] = cellStyle;
        if (style.empty() && !cellStyle.empty()) style = cellStyle;
        if (cellStyle.rfind("Match", 0) == 0) style = cellStyle;
        ++col;
    }
    while (cells.size() > 1 && cells.back().empty()) {
        cells.pop_back();
        styles.pop_back();
    }
    if (cellStyles) *cellStyles = std::move(styles);
    return cells;
}

std::string excelColumnName(int index) {
    std::string name;
    ++index;
    while (index > 0) {
        int rem = (index - 1) % 26;
        name.insert(name.begin(), static_cast<char>('A' + rem));
        index = (index - 1) / 26;
    }
    return name;
}

void resetPreviewColumns(HWND list, size_t colCount) {
    if (!list) return;
    while (ListView_DeleteColumn(list, 0)) {
    }
    colCount = std::max<size_t>(colCount, 12);
    colCount = std::min<size_t>(colCount, 64);
    int zoom = g_app ? std::max(60, std::min(200, g_app->previewZoomPercent)) : 100;
    for (size_t i = 0; i < colCount; ++i) {
        std::string name = excelColumnName(static_cast<int>(i));
        std::wstring title = u8w(name);
        LVCOLUMNW col{};
        col.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
        col.pszText = title.data();
        int baseWidth = i == 0 ? 210 : (i == 4 || i == 6 ? 300 : 110);
        col.cx = std::max(45, baseWidth * zoom / 100);
        col.iSubItem = static_cast<int>(i);
        ListView_InsertColumn(list, static_cast<int>(i), &col);
    }
}

bool previewRowMatchesFilter(const PreviewSheetRow& row, int statusFilter) {
    if (statusFilter < 0) return true;
    return row.status == statusFilter;
}

std::string phaseFromText(const std::string& text) {
    if (text.rfind("A相", 0) == 0 || text == "A 相") return "A";
    if (text.rfind("B相", 0) == 0 || text == "B 相") return "B";
    if (text.rfind("C相", 0) == 0 || text == "C 相") return "C";
    if (text.rfind("T相", 0) == 0 || text == "T 相") return "T";
    return "";
}

std::string labelWithoutPhase(std::string text) {
    if (text.rfind("A相", 0) == 0 || text.rfind("B相", 0) == 0 ||
        text.rfind("C相", 0) == 0 || text.rfind("T相", 0) == 0) {
        return text.substr(std::string("A相").size());
    }
    return text;
}

bool previewRowMatchesPhase(const PreviewSheetRow& row, const std::string& phaseFilter) {
    if (phaseFilter.empty()) return true;
    if (row.status == 1 || row.status == 2 || row.status == 3) return row.phase == phaseFilter;
    if (row.status == 6) return row.phase.empty() || row.phase == phaseFilter;
    return true;
}

bool previewRowMatchesSearch(const PreviewSheetRow& row, const std::string& searchText) {
    if (trimAscii(searchText).empty()) return true;
    for (const auto& cell : row.cells) {
        if (textContainsFilter(cell, searchText)) return true;
    }
    return false;
}

void capturePreviewViewport(AppState& app, int& topModelRow, int& horzPos) {
    topModelRow = -1;
    horzPos = 0;
    if (!app.previewList) return;
    int topItem = (int)SendMessageW(app.previewList, LVM_GETTOPINDEX, 0, 0);
    LVITEMW lv{};
    lv.mask = LVIF_PARAM;
    lv.iItem = topItem;
    if (ListView_GetItem(app.previewList, &lv)) topModelRow = (int)lv.lParam;
    SCROLLINFO si{};
    si.cbSize = sizeof(si);
    si.fMask = SIF_POS;
    if (GetScrollInfo(app.previewList, SB_HORZ, &si)) horzPos = si.nPos;
}

void restorePreviewViewport(AppState& app, int topModelRow, int horzPos) {
    if (!app.previewList) return;
    int count = ListView_GetItemCount(app.previewList);
    if (count <= 0) return;

    int targetVisibleIndex = -1;
    if (topModelRow >= 0) {
        for (int i = 0; i < count; ++i) {
            LVITEMW lv{};
            lv.mask = LVIF_PARAM;
            lv.iItem = i;
            if (ListView_GetItem(app.previewList, &lv) && (int)lv.lParam == topModelRow) {
                targetVisibleIndex = i;
                break;
            }
        }
    }

    RECT rc{};
    int rowHeight = 18;
    if (ListView_GetItemRect(app.previewList, 0, &rc, LVIR_BOUNDS)) {
        rowHeight = std::max(1L, rc.bottom - rc.top);
    }
    if (targetVisibleIndex > 0) {
        ListView_EnsureVisible(app.previewList, targetVisibleIndex, FALSE);
        int currentTop = (int)SendMessageW(app.previewList, LVM_GETTOPINDEX, 0, 0);
        int deltaRows = targetVisibleIndex - currentTop;
        if (deltaRows != 0) ListView_Scroll(app.previewList, 0, deltaRows * rowHeight);
    }

    if (horzPos > 0) {
        SCROLLINFO si{};
        si.cbSize = sizeof(si);
        si.fMask = SIF_POS;
        int current = GetScrollInfo(app.previewList, SB_HORZ, &si) ? si.nPos : 0;
        if (horzPos != current) ListView_Scroll(app.previewList, horzPos - current, 0);
    }
}

void populatePreviewList(AppState& app, int forcedTopModelRow = -1, int forcedHorzPos = -1) {
    int oldTopModelRow = -1;
    int oldHorzPos = 0;
    if (forcedTopModelRow >= 0) {
        oldTopModelRow = forcedTopModelRow;
        oldHorzPos = std::max(0, forcedHorzPos);
    } else {
        capturePreviewViewport(app, oldTopModelRow, oldHorzPos);
    }
    if (!app.previewList) return;
    SendMessageW(app.previewList, WM_SETREDRAW, FALSE, 0);
    ListView_DeleteAllItems(app.previewList);
    if (app.previewSheets.empty()) {
        resetPreviewColumns(app.previewList, 12);
        SendMessageW(app.previewList, WM_SETREDRAW, TRUE, 0);
        InvalidateRect(app.previewList, nullptr, TRUE);
        return;
    }
    if (app.activePreviewSheet < 0 || app.activePreviewSheet >= (int)app.previewSheets.size()) {
        app.activePreviewSheet = 0;
    }
    const PreviewSheet& sheet = app.previewSheets[app.activePreviewSheet];
    resetPreviewColumns(app.previewList, sheet.maxCols);
    int statusFilter = app.previewStatusFilter;
    int visibleRows = 0;
    for (size_t i = 0; i < sheet.rows.size(); ++i) {
        const PreviewSheetRow& row = sheet.rows[i];
        if (!previewRowMatchesFilter(row, statusFilter)) continue;
        if (!previewRowMatchesPhase(row, app.previewPhaseFilter)) continue;
        if (!previewRowMatchesSearch(row, app.previewSearchText)) continue;
        LVITEMW item{};
        std::wstring firstText = row.cells.empty() ? L"" : u8w(row.cells[0]);
        item.mask = LVIF_TEXT | LVIF_PARAM;
        item.iItem = visibleRows++;
        item.pszText = firstText.data();
        item.lParam = static_cast<LPARAM>(i);
        ListView_InsertItem(app.previewList, &item);
        for (size_t c = 1; c < row.cells.size(); ++c) {
            std::wstring cellTextW = u8w(row.cells[c]);
            ListView_SetItemText(app.previewList, visibleRows - 1, static_cast<int>(c),
                                 cellTextW.data());
        }
    }
    SendMessageW(app.previewList, WM_SETREDRAW, TRUE, 0);
    restorePreviewViewport(app, oldTopModelRow, oldHorzPos);
    InvalidateRect(app.previewList, nullptr, TRUE);
}

bool isAbcPhase(const std::string& phase) {
    return phase == "A" || phase == "B" || phase == "C";
}

bool isEditablePreviewCell(const AppState& app, int rowIndex, int colIndex) {
    if (app.activePreviewSheet < 0 || app.activePreviewSheet >= (int)app.previewSheets.size()) return false;
    const auto& rows = app.previewSheets[app.activePreviewSheet].rows;
    if (rowIndex < 0 || rowIndex >= (int)rows.size()) return false;
    const PreviewSheetRow& row = rows[rowIndex];
    if (colIndex < 1 || colIndex > 4) return false;
    if (!(row.status == 1 || row.status == 2 || row.status == 3)) return false;
    return !row.cells.empty() && !row.cells[0].empty();
}

int previewRowIndexFromListItem(HWND list, int item) {
    LVITEMW lv{};
    lv.mask = LVIF_PARAM;
    lv.iItem = item;
    if (!ListView_GetItem(list, &lv)) return -1;
    return static_cast<int>(lv.lParam);
}

void syncPreviewPhaseGroup(AppState& app, int rowIndex, int colIndex, const std::string& value) {
    if (app.activePreviewSheet < 0 || app.activePreviewSheet >= (int)app.previewSheets.size()) return;
    PreviewSheet& sheet = app.previewSheets[app.activePreviewSheet];
    if (rowIndex < 0 || rowIndex >= (int)sheet.rows.size()) return;
    const PreviewSheetRow& row = sheet.rows[rowIndex];
    if (!isAbcPhase(row.phase) || row.cells.empty()) return;
    std::string baseLabel = labelWithoutPhase(row.cells[0]);
    for (auto& other : sheet.rows) {
        if (!isAbcPhase(other.phase) || other.cells.empty() || other.cells[0].empty()) continue;
        if (labelWithoutPhase(other.cells[0]) != baseLabel) continue;
        if ((int)other.cells.size() <= colIndex) other.cells.resize(colIndex + 1);
        other.cells[colIndex] = value;
    }
}

void commitPreviewEdit(AppState& app, bool save) {
    HWND edit = app.previewEdit;
    if (!edit) return;
    int rowIndex = app.editPreviewRow;
    int colIndex = app.editPreviewCol;
    int topModelRow = app.editPreviewTopModelRow;
    int horzPos = app.editPreviewHorzPos;
    app.previewEdit = nullptr;
    app.editPreviewRow = -1;
    app.editPreviewCol = -1;
    app.editPreviewTopModelRow = -1;
    app.editPreviewHorzPos = 0;

    if (save && app.activePreviewSheet >= 0 && app.activePreviewSheet < (int)app.previewSheets.size() &&
        rowIndex >= 0 && rowIndex < (int)app.previewSheets[app.activePreviewSheet].rows.size()) {
        int len = GetWindowTextLengthW(edit);
        std::wstring wtext(len + 1, L'\0');
        GetWindowTextW(edit, wtext.data(), len + 1);
        wtext.resize(len);
        std::string value = w8(wtext);
        PreviewSheetRow& row = app.previewSheets[app.activePreviewSheet].rows[rowIndex];
        if ((int)row.cells.size() <= colIndex) row.cells.resize(colIndex + 1);
        row.cells[colIndex] = value;
        syncPreviewPhaseGroup(app, rowIndex, colIndex, value);
        app.reverseXmlDirty = true;
    }

    DestroyWindow(edit);
    populatePreviewList(app, topModelRow, horzPos);
}

void startPreviewEdit(AppState& app, int listItem, int subItem) {
    int rowIndex = previewRowIndexFromListItem(app.previewList, listItem);
    if (!isEditablePreviewCell(app, rowIndex, subItem)) return;
    commitPreviewEdit(app, true);
    int topModelRow = -1;
    int horzPos = 0;
    capturePreviewViewport(app, topModelRow, horzPos);

    RECT rc{};
    rc.top = subItem;
    rc.left = LVIR_BOUNDS;
    if (!SendMessageW(app.previewList, LVM_GETSUBITEMRECT, listItem, (LPARAM)&rc)) return;
    POINT pts[2] = {{rc.left, rc.top}, {rc.right, rc.bottom}};
    MapWindowPoints(app.previewList, app.hwnd, pts, 2);
    PreviewSheetRow& row = app.previewSheets[app.activePreviewSheet].rows[rowIndex];
    std::string text = subItem < (int)row.cells.size() ? row.cells[subItem] : "";
    HWND edit = CreateWindowExW(WS_EX_CLIENTEDGE, L"EDIT", u8w(text).c_str(),
                                WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL | ES_NOHIDESEL,
                                pts[0].x, pts[0].y,
                                std::max<LONG>(90, pts[1].x - pts[0].x), std::max<LONG>(24, pts[1].y - pts[0].y),
                                app.hwnd, (HMENU)(INT_PTR)IDC_PREVIEW_CELL_EDIT, app.inst, nullptr);
    applyFont(app, edit);
    SetWindowPos(edit, HWND_TOP, pts[0].x, pts[0].y,
                 std::max<LONG>(90, pts[1].x - pts[0].x), std::max<LONG>(24, pts[1].y - pts[0].y),
                 SWP_SHOWWINDOW);
    app.previewEdit = edit;
    app.editPreviewRow = rowIndex;
    app.editPreviewCol = subItem;
    app.editPreviewTopModelRow = topModelRow;
    app.editPreviewHorzPos = horzPos;
    SendMessageW(edit, EM_SETSEL, 0, -1);
    SetFocus(edit);
}

void refreshPreviewFromWorkbook(AppState& app, const std::string& workbookPath) {
    if (app.previewEdit) {
        if (app.previewStatus) {
            SetWindowTextW(app.previewStatus, L"\u6570\u636E\u5DF2\u5199\u5165\uFF0C\u7F16\u8F91\u7ED3\u675F\u540E\u518D\u5237\u65B0\u9884\u89C8");
        }
        return;
    }
    commitPreviewEdit(app, true);
    int oldActiveSheet = app.activePreviewSheet;
    std::string oldWorkbook = app.activePreviewWorkbook;
    app.activePreviewWorkbook = workbookPath;
    app.reverseXmlDirty = true;
    if (workbookPath.empty() || !fs::exists(fs::u8path(workbookPath))) {
        app.previewSheets.clear();
        app.activePreviewSheet = 0;
        if (app.previewSheet) SendMessageW(app.previewSheet, CB_RESETCONTENT, 0, 0);
        if (app.previewStatus) SetWindowTextW(app.previewStatus, L"\x5C1A\x672A\x751F\x6210\x8868\x683C");
        populatePreviewList(app);
        return;
    }

    tinyxml2::XMLDocument doc;
    std::string xml = readAllText(fs::u8path(workbookPath));
    if (doc.Parse(xml.c_str(), xml.size()) != tinyxml2::XML_SUCCESS) {
        app.previewSheets.clear();
        app.activePreviewSheet = 0;
        if (app.previewSheet) SendMessageW(app.previewSheet, CB_RESETCONTENT, 0, 0);
        if (app.previewStatus) SetWindowTextW(app.previewStatus, L"\x8868\x683C\x9884\x89C8\x89E3\x6790\x5931\x8D25");
        populatePreviewList(app);
        return;
    }

    std::vector<PreviewSheet> loadedSheets;
    const tinyxml2::XMLElement* workbook = doc.FirstChildElement("Workbook");
    for (const tinyxml2::XMLElement* ws = workbook ? workbook->FirstChildElement("Worksheet") : nullptr;
         ws;
         ws = ws->NextSiblingElement("Worksheet")) {
        PreviewSheet sheet;
        sheet.name = attrValue(ws, "ss:Name");
        const tinyxml2::XMLElement* table = ws->FirstChildElement("Table");
        std::string currentPhase;
        std::string lastDataPhase;
        for (const tinyxml2::XMLElement* row = table ? table->FirstChildElement("Row") : nullptr;
             row;
             row = row->NextSiblingElement("Row")) {
            std::string style;
            PreviewSheetRow previewRow;
            previewRow.cells = rowCells(row, style, &previewRow.cellStyles);
            previewRow.originalCells = previewRow.cells;
            previewRow.status = previewStatusFromStyle(style);
            std::string firstCell = previewRow.cells.empty() ? "" : previewRow.cells[0];
            std::string explicitPhase = phaseFromText(firstCell);
            if (previewRow.status == 6 && !explicitPhase.empty()) currentPhase = explicitPhase;
            if (previewRow.status == 1 || previewRow.status == 2 || previewRow.status == 3) {
                previewRow.phase = explicitPhase.empty() ? (firstCell.empty() ? lastDataPhase : currentPhase) : explicitPhase;
                if (!previewRow.phase.empty()) lastDataPhase = previewRow.phase;
            } else if (previewRow.status == 6) {
                previewRow.phase = explicitPhase;
            }
            sheet.maxCols = std::max(sheet.maxCols, previewRow.cells.size());
            sheet.rows.push_back(std::move(previewRow));
        }
        if (sheet.maxCols == 0) sheet.maxCols = 12;
        loadedSheets.push_back(std::move(sheet));
    }

    app.previewSheets = std::move(loadedSheets);
    if (oldWorkbook == workbookPath &&
        oldActiveSheet >= 0 &&
        oldActiveSheet < (int)app.previewSheets.size()) {
        app.activePreviewSheet = oldActiveSheet;
    } else {
        app.activePreviewSheet = 0;
    }
    if (app.previewSheet) {
        SendMessageW(app.previewSheet, CB_RESETCONTENT, 0, 0);
        for (const auto& sheet : app.previewSheets) {
            SendMessageW(app.previewSheet, CB_ADDSTRING, 0, (LPARAM)u8w(sheet.name).c_str());
        }
        if (!app.previewSheets.empty()) SendMessageW(app.previewSheet, CB_SETCURSEL, app.activePreviewSheet, 0);
    }
    populatePreviewList(app);
    if (app.previewStatus) {
        std::string text = "Workbook synced: " + workbookPath + ", sheets: " + std::to_string(app.previewSheets.size());
        SetWindowTextW(app.previewStatus, u8w(text).c_str());
    }
}

PqMqEventFn makeMqEventCallback(AppState& app) {
    HWND hwnd = app.hwnd;
    return [hwnd](const PqMqEvent& ev) {
        auto* copy = new PqMqEvent(ev);
        if (!PostMessageW(hwnd, WM_PQ_MQ_EVENT, 0, (LPARAM)copy)) delete copy;
    };
}

std::string selectedFrontType(AppState& app) {
    int idx = (int)SendMessageW(app.frontType, CB_GETCURSEL, 0, 0);
    wchar_t buf[128]{};
    SendMessageW(app.frontType, CB_GETLBTEXT, idx < 0 ? 0 : idx, (LPARAM)buf);
    return w8(buf);
}

bool openFileDialog(HWND owner, const wchar_t* title, const wchar_t* filter, std::string& out) {
    wchar_t file[4096]{};
    OPENFILENAMEW ofn{};
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner = owner;
    ofn.lpstrTitle = title;
    ofn.lpstrFilter = filter;
    ofn.lpstrFile = file;
    ofn.nMaxFile = (DWORD)std::size(file);
    ofn.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST;
    if (!GetOpenFileNameW(&ofn)) return false;
    out = w8(file);
    return true;
}

bool saveFileDialog(HWND owner, const wchar_t* title, const wchar_t* filter, const wchar_t* defaultExt, std::string& out) {
    wchar_t file[4096]{};
    OPENFILENAMEW ofn{};
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner = owner;
    ofn.lpstrTitle = title;
    ofn.lpstrFilter = filter;
    ofn.lpstrDefExt = defaultExt;
    ofn.lpstrFile = file;
    ofn.nMaxFile = (DWORD)std::size(file);
    ofn.Flags = OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT;
    if (!GetSaveFileNameW(&ofn)) return false;
    out = w8(file);
    return true;
}

std::vector<std::string> collectOriginFiles(const fs::path& dir) {
    std::vector<std::string> files;
    if (!fs::exists(dir)) return files;
    for (const auto& entry : fs::directory_iterator(dir)) {
        if (!entry.is_regular_file()) continue;
        std::string name = entry.path().filename().u8string();
        if (name.rfind("origin", 0) == 0 && entry.path().extension() == ".txt") {
            files.push_back(entry.path().u8string());
        }
    }
    std::sort(files.begin(), files.end());
    return files;
}

std::vector<std::string> collectJsonDataFiles(const fs::path& dir) {
    std::vector<std::string> files;
    if (!fs::exists(dir)) return files;
    for (const auto& entry : fs::directory_iterator(dir)) {
        if (!entry.is_regular_file()) continue;
        std::string name = entry.path().filename().u8string();
        if (name.rfind("jsondata", 0) == 0 &&
            (entry.path().extension() == ".txt" || entry.path().extension() == ".json")) {
            files.push_back(entry.path().u8string());
        }
    }
    std::sort(files.begin(), files.end());
    return files;
}

std::string joinPaths(const std::vector<std::string>& paths) {
    std::string out;
    for (const auto& p : paths) {
        if (!out.empty()) out += "\r\n";
        out += p;
    }
    return out;
}

void prepareTraceWorkspace(AppState& app,
                           PqToolConfig& cfg,
                           const PqLedgerDevice& d,
                           const PqLedgerMonitor& m,
                           bool updateUi) {
    fs::path dir = fs::u8path(pqTraceDirectoryFor(cfg, d, m));
    fs::create_directories(dir);

    std::string xmlPath = pqFindDeviceXmlPath(cfg, d);
    if (!xmlPath.empty()) cfg.xmlPath = xmlPath;
    cfg.jsonDataPaths = collectJsonDataFiles(dir);
    cfg.jsonDataPath = joinPaths(cfg.jsonDataPaths);
    cfg.originPaths = collectOriginFiles(dir);
    cfg.outputPath = (dir / "final_sorted.xls").u8string();

    if (updateUi) {
        if (!cfg.xmlPath.empty()) setText(app.hwnd, IDC_XML_PATH, cfg.xmlPath);
        setText(app.hwnd, IDC_JSON_PATH, cfg.jsonDataPath);
        setText(app.hwnd, IDC_ORIGIN_PATHS, joinPaths(cfg.originPaths));
        setText(app.hwnd, IDC_OUTPUT_PATH, cfg.outputPath);
    }
}

void addJsonMonitorChoice(AppState& app,
                          std::unordered_set<std::string>& seen,
                          const std::string& label,
                          const std::string& traceDir,
                          int device,
                          int monitor) {
    std::string key = traceDir.empty() ? "all" : normalizedPathPrefix(traceDir);
    if (!seen.insert(key).second) return;
    app.jsonMonitorChoices.push_back({label, traceDir, device, monitor});
}

std::string contextStringValue(const fs::path& contextPath, const char* key) {
    try {
        if (!fs::exists(contextPath)) return "";
        json context = json::parse(readAllText(contextPath));
        auto it = context.find(key);
        return it == context.end() ? "" : jsonScalarString(*it);
    } catch (...) {
        return "";
    }
}

void refreshJsonMonitorChoices(AppState& app, const std::string& selectedTraceDir) {
    if (!app.jsonMonitor) return;
    if (!app.jsonMonitorRefreshing &&
        SendMessageW(app.jsonMonitor, CB_GETDROPPEDSTATE, 0, 0)) {
        app.jsonMonitorRefreshPending = true;
        app.pendingJsonMonitorTraceDir = selectedTraceDir;
        return;
    }
    std::string selectedKey = selectedTraceDir.empty() ? "" : normalizedPathPrefix(selectedTraceDir);
    app.jsonMonitorRefreshing = true;
    SendMessageW(app.jsonMonitor, CB_RESETCONTENT, 0, 0);
    app.jsonMonitorChoices.clear();
    std::unordered_set<std::string> seen;

    addJsonMonitorChoice(app, seen, "全部测点", "", -1, -1);

    PqToolConfig cfg = readConfig(app.hwnd);
    for (size_t i = 0; i < app.devices.size(); ++i) {
        const auto& d = app.devices[i];
        for (size_t j = 0; j < d.monitors.size(); ++j) {
            const auto& m = d.monitors[j];
            std::string traceDir = pqTraceDirectoryFor(cfg, d, m);
            std::string label = "进程 " + (d.processNo.empty() ? std::string("1") : d.processNo)
                              + " / " + (d.name.empty() ? d.id : d.name)
                              + " / " + (m.name.empty() ? m.id : m.name);
            addJsonMonitorChoice(app, seen, truncateText(label, 120), traceDir, (int)i, (int)j);
        }
    }

    for (const auto& item : app.jsonItems) {
        if (item.traceDir.empty()) continue;
        std::string label = item.monitorId.empty()
                                ? fs::u8path(item.traceDir).filename().u8string()
                                : "测点 " + item.monitorId;
        std::string name = contextStringValue(fs::u8path(item.traceDir) / "trace_context.json", "monitorName");
        if (!name.empty()) label = name + (item.monitorId.empty() ? "" : (" / " + item.monitorId));
        addJsonMonitorChoice(app, seen, truncateText(label, 120), item.traceDir, -1, -1);
    }

    int selectedIndex = selectedKey.empty() ? 0 : -1;
    for (size_t i = 0; i < app.jsonMonitorChoices.size(); ++i) {
        const auto& choice = app.jsonMonitorChoices[i];
        SendMessageW(app.jsonMonitor, CB_ADDSTRING, 0, (LPARAM)u8w(choice.label).c_str());
        if (!selectedKey.empty() && !choice.traceDir.empty() &&
            normalizedPathPrefix(choice.traceDir) == selectedKey) {
            selectedIndex = (int)i;
        }
    }
    if (selectedIndex < 0 && !app.jsonMonitorChoices.empty()) selectedIndex = 0;
    if (selectedIndex >= 0) SendMessageW(app.jsonMonitor, CB_SETCURSEL, selectedIndex, 0);
    app.jsonMonitorRefreshing = false;
    app.jsonMonitorRefreshPending = false;
    app.pendingJsonMonitorTraceDir.clear();
}

void selectJsonMonitorChoice(AppState& app, int index) {
    if (index < 0 || index >= (int)app.jsonMonitorChoices.size()) return;
    const JsonMonitorChoice choice = app.jsonMonitorChoices[index];
    app.activeTraceDir = choice.traceDir;

    std::string outputPath;
    if (choice.traceDir.empty()) {
        app.selectedJson = latestVisibleJsonIndex(app);
        rebuildJsonTree(app);
        updateJsonDetail(app);
        return;
    }

    PqToolConfig cfg = readConfig(app.hwnd);
    if (choice.device >= 0 && choice.device < (int)app.devices.size() &&
        choice.monitor >= 0 && choice.monitor < (int)app.devices[choice.device].monitors.size()) {
        app.selectedDevice = choice.device;
        app.selectedMonitor = choice.monitor;
        prepareTraceWorkspace(app, cfg, app.devices[choice.device],
                              app.devices[choice.device].monitors[choice.monitor], true);
        outputPath = cfg.outputPath;
        updateDetails(app);
    } else {
        fs::path dir = fs::u8path(choice.traceDir);
        std::string xmlPath = contextStringValue(dir / "trace_context.json", "xmlPath");
        outputPath = contextStringValue(dir / "trace_context.json", "outputPath");
        if (outputPath.empty()) outputPath = (dir / "final_sorted.xls").u8string();
        if (!xmlPath.empty()) setText(app.hwnd, IDC_XML_PATH, xmlPath);
        setText(app.hwnd, IDC_JSON_PATH, joinPaths(collectJsonDataFiles(dir)));
        setText(app.hwnd, IDC_ORIGIN_PATHS, joinPaths(collectOriginFiles(dir)));
        setText(app.hwnd, IDC_OUTPUT_PATH, outputPath);
    }

    app.selectedJson = latestVisibleJsonIndex(app);
    rebuildJsonTree(app);
    updateJsonDetail(app);
    refreshPreviewWorkbookChoices(app, outputPath);
    if (!outputPath.empty()) refreshPreviewFromWorkbook(app, outputPath);
}

void updatePathsForSelection(AppState& app) {
    if (app.selectedDevice < 0 || app.selectedDevice >= (int)app.devices.size()) return;
    PqToolConfig cfg = readConfig(app.hwnd);
    const auto& d = app.devices[app.selectedDevice];
    if (app.selectedMonitor >= 0 && app.selectedMonitor < (int)d.monitors.size()) {
        app.activeTraceDir = pqTraceDirectoryFor(cfg, d, d.monitors[app.selectedMonitor]);
        prepareTraceWorkspace(app, cfg, d, d.monitors[app.selectedMonitor], true);
        refreshJsonMonitorChoices(app, app.activeTraceDir);
        app.selectedJson = latestVisibleJsonIndex(app);
        rebuildJsonTree(app);
        updateJsonDetail(app);
        refreshPreviewWorkbookChoices(app, cfg.outputPath);
        if (fs::exists(fs::u8path(cfg.outputPath))) {
            refreshPreviewFromWorkbook(app, cfg.outputPath);
        }
        return;
    }
    app.activeTraceDir.clear();
    refreshJsonMonitorChoices(app, "");
    rebuildJsonTree(app);
    updateJsonDetail(app);
    std::string xmlPath = pqFindDeviceXmlPath(cfg, d);
    if (!xmlPath.empty()) setText(app.hwnd, IDC_XML_PATH, xmlPath);
}

void showPage(AppState& app, int index) {
    ShowWindow(app.pageConfig, index == 0 ? SW_SHOW : SW_HIDE);
    ShowWindow(app.pageLedger, index == 1 ? SW_SHOW : SW_HIDE);
    ShowWindow(app.pageJson, index == 2 ? SW_SHOW : SW_HIDE);
    ShowWindow(app.pagePreview, index == 3 ? SW_SHOW : SW_HIDE);
    ShowWindow(app.pageXmlPreview, index == 4 ? SW_SHOW : SW_HIDE);
    if (index == 3) {
        PqToolConfig cfg = readConfig(app.hwnd);
        std::string selected = app.activePreviewWorkbook.empty() ? cfg.outputPath : app.activePreviewWorkbook;
        refreshPreviewWorkbookChoices(app, selected);
        if (app.previewSheets.empty() && !selected.empty() && fs::exists(fs::u8path(selected))) {
            refreshPreviewFromWorkbook(app, selected);
        }
    } else if (index == 4) {
        if (app.reverseXmlDirty || app.generatedXmlText.empty()) generateReverseXml(app, false);
        updateXmlPreviewText(app);
    }
}

void selectPage(AppState& app, int index) {
    if (app.tab) SendMessageW(app.tab, TCM_SETCURSEL, index, 0);
    showPage(app, index);
}

void runGetLedger(AppState& app) {
    try {
        PqToolConfig cfg = readConfig(app.hwnd);
        appendLogW(app, L"开始获取台账和 ICD/XML...");
        std::string firstXml;
        pqFetchLedgerAndIcd(cfg, app.devices, firstXml, [&](const std::string& s) { appendLog(app, s); });
        populateTree(app);
        updateDetails(app);
        refreshJsonMonitorChoices(app, app.activeTraceDir);
        if (!firstXml.empty()) setText(app.hwnd, IDC_XML_PATH, firstXml);
        appendLogW(app, L"台账树已刷新。");
    } catch (const std::exception& e) {
        appendLog(app, std::string("获取台账失败: ") + e.what());
        MessageBoxW(app.hwnd, u8w(e.what()).c_str(), L"获取台账失败", MB_ICONERROR);
    }
}

void runInitMq(AppState& app) {
    try {
        PqToolConfig cfg = readConfig(app.hwnd);
        pqInitializeMq(cfg,
                       [&](const std::string& s) { appendLog(app, s); },
                       makeMqEventCallback(app));
    } catch (const std::exception& e) {
        appendLog(app, std::string("初始化 MQ 失败: ") + e.what());
    }
}

void runTrace(AppState& app) {
    try {
        if (app.selectedDevice < 0 || app.selectedMonitor < 0) {
            MessageBoxW(app.hwnd, L"请先在左侧选择一个测点，选中装置或进程时不会发送数据追踪消息。", L"数据追踪", MB_ICONINFORMATION);
            return;
        }
        PqToolConfig cfg = readConfig(app.hwnd);
        const auto& d = app.devices[app.selectedDevice];
        const auto& m = d.monitors[app.selectedMonitor];
        std::string traceDir = pqTraceDirectoryFor(cfg, d, m);
        resetJsonSession(app, traceDir);
        pqClearTraceRecords(cfg, d, m);
        appendLog(app, "已清空当前测点旧文本记录: " + traceDir);
        prepareTraceWorkspace(app, cfg, d, m, true);
        app.autoPreviewEnabled = true;
        selectPage(app, 3);
        autoParseTraceDir(app, traceDir, "trace-start");
        pqSendTraceRequest(cfg, d, m, selectedFrontType(app),
                           [&](const std::string& s) { appendLog(app, s); },
                           makeMqEventCallback(app));
    } catch (const std::exception& e) {
        appendLog(app, std::string("数据追踪失败: ") + e.what());
    }
}

void runParse(AppState& app) {
    PqToolConfig cfg = readConfig(app.hwnd);
    std::string err;
    appendLogW(app, L"开始解析生成表格...");
    std::vector<std::string> jsonPaths = cfg.jsonDataPaths.empty() ? splitPathList(cfg.jsonDataPath) : cfg.jsonDataPaths;
    bool ok = pqRunParser(cfg.xmlPath, jsonPaths, cfg.originPaths, cfg.outputPath, &err, selectedFrontType(app));
    if (ok) {
        refreshPreviewWorkbookChoices(app, cfg.outputPath);
        refreshPreviewFromWorkbook(app, cfg.outputPath);
        appendLog(app, "表格生成完成: " + cfg.outputPath);
        MessageBoxW(app.hwnd, u8w("表格生成完成: " + cfg.outputPath).c_str(), L"完成", MB_ICONINFORMATION);
    } else {
        appendLog(app, "表格生成失败: " + err);
        MessageBoxW(app.hwnd, u8w(err).c_str(), L"表格生成失败", MB_ICONERROR);
    }
}

std::string currentWorkbookForPreview(AppState& app) {
    if (!app.activePreviewWorkbook.empty()) return app.activePreviewWorkbook;
    if (app.previewWorkbook) {
        int idx = (int)SendMessageW(app.previewWorkbook, CB_GETCURSEL, 0, 0);
        if (idx >= 0 && idx < (int)app.previewWorkbooks.size()) return app.previewWorkbooks[idx].path;
    }
    return readConfig(app.hwnd).outputPath;
}

void runImportIcd(AppState& app) {
    std::string icdPath;
    if (!openFileDialog(app.hwnd,
                        L"\x9009\x62E9ICD\x6587\x4EF6",
                        L"ICD/XML Files\0*.icd;*.xml\0All Files\0*.*\0",
                        icdPath)) {
        return;
    }

    std::string workbook = currentWorkbookForPreview(app);
    if (workbook.empty() || !fs::exists(fs::u8path(workbook))) {
        MessageBoxW(app.hwnd, L"\x8BF7\x5148\x751F\x6210\x6216\x9009\x62E9\x4E00\x4E2A\x8868\x683C\x6587\x4EF6\x3002",
                    L"\x5BFC\x5165ICD", MB_ICONINFORMATION);
        return;
    }

    std::string msg;
    bool ok = pqApplyIcdDescriptionsToWorkbook(icdPath, workbook, &msg);
    appendLog(app, msg);
    if (ok) {
        refreshPreviewFromWorkbook(app, workbook);
        MessageBoxW(app.hwnd, u8w(msg).c_str(), L"\x5BFC\x5165ICD", MB_ICONINFORMATION);
    } else {
        MessageBoxW(app.hwnd, u8w(msg).c_str(), L"\x5BFC\x5165ICD\x5931\x8D25", MB_ICONERROR);
    }
}

std::string xmlLocalName(const char* name) {
    if (!name) return "";
    std::string s(name);
    size_t pos = s.find(':');
    return pos == std::string::npos ? s : s.substr(pos + 1);
}

std::string xmlAttr(const tinyxml2::XMLElement* e, const char* name) {
    const char* v = e ? e->Attribute(name) : nullptr;
    return v ? v : "";
}

struct ReverseSheetSpec {
    std::string topic;
    std::string dataType;
    std::string wiring;
};

ReverseSheetSpec reverseSpecForSheet(const std::string& sheetName) {
    ReverseSheetSpec spec;
    spec.topic = sheetName.find("实时") == std::string::npos ? "HISDATA" : "RTDATA";
    spec.dataType = sheetName.find("03") != std::string::npos ? "03" :
                    sheetName.find("02") != std::string::npos ? "02" : "01";
    spec.wiring = (sheetName.find("角") != std::string::npos) ? "delta" : "star";
    return spec;
}

bool reverseWiringAllowed(const std::string& valueWiring, const std::string& sheetWiring) {
    return valueWiring.empty() || valueWiring == "common" || valueWiring == sheetWiring;
}

std::string cleanPhaseLabelForReverse(std::string label) {
    label = labelWithoutPhase(label);
    return trimAscii(label);
}

std::string reverseNameFromField(const std::string& field, const std::string& arrayBase) {
    std::string name = field;
    std::vector<std::string> parts;
    std::stringstream ss(field);
    std::string part;
    while (std::getline(ss, part, '_')) parts.push_back(part);
    if (parts.size() >= 3 && (parts[1] == "A" || parts[1] == "B" || parts[1] == "C" || parts[1] == "T")) {
        name.clear();
        for (size_t i = 2; i < parts.size(); ++i) {
            if (i > 2) name += "_";
            name += parts[i];
        }
    }
    std::smatch m;
    static const std::regex rangeRe(R"(^(.*)\[(\d+)-(\d+)\](.*)$)");
    if (std::regex_match(name, m, rangeRe)) {
        std::string start = m[2].str();
        std::string end = m[3].str();
        static const std::regex baseRe(R"(^\s*(-?\d+)\s*-->\s*(-?\d+)\s*$)");
        std::smatch bm;
        if (std::regex_match(arrayBase, bm, baseRe)) {
            start = bm[1].str();
            end = bm[2].str();
        }
        return m[1].str() + "%" + start + "," + end + "%" + m[4].str();
    }
    return name;
}

bool parseConfigText(const std::string& config, std::string& doPath, std::string& daPath) {
    std::smatch m;
    static const std::regex doRe("DO=\"([^\"]*)\"");
    static const std::regex daRe("DA=\"([^\"]*)\"");
    bool ok = false;
    if (std::regex_search(config, m, doRe)) {
        doPath = m[1].str();
        ok = true;
    }
    if (std::regex_search(config, m, daRe)) {
        daPath = m[1].str();
        ok = true;
    }
    return ok;
}

std::string placeholderForValueOffset(const std::string& offsetText) {
    int offset = 0;
    try {
        offset = offsetText.empty() ? 0 : std::stoi(offsetText);
    } catch (...) {
        offset = 0;
    }
    if (offset <= 0) return "%-" + std::to_string(-offset);
    return "%" + std::to_string(offset);
}

std::string reverseDaForXml(std::string daPath, const std::string& valueOffset) {
    if (valueOffset.empty()) return daPath;
    static const std::regex rangeRe(R"(\[\d+-\d+\])");
    return std::regex_replace(daPath, rangeRe, "[" + placeholderForValueOffset(valueOffset) + "]",
                              std::regex_constants::format_first_only);
}

struct ReverseRowEdit {
    std::string label;
    std::string name;
    std::string arrayBase;
    std::string valueOffset;
    std::string finalOffset;
    std::string doPath;
    std::string daPath;
    std::string originalDoPath;
    std::string originalDaPath;
    bool modified = false;
};

std::vector<ReverseRowEdit> collectReverseRows(const AppState& app) {
    std::vector<ReverseRowEdit> rows;
    if (app.activePreviewSheet < 0 || app.activePreviewSheet >= (int)app.previewSheets.size()) return rows;
    const PreviewSheet& sheet = app.previewSheets[app.activePreviewSheet];
    for (const auto& row : sheet.rows) {
        if (!(row.status == 1 || row.status == 2 || row.status == 3)) continue;
        if (row.cells.size() <= 8 || row.cells[0].empty()) continue;
        ReverseRowEdit edit;
        edit.label = cleanPhaseLabelForReverse(row.cells[0]);
        edit.arrayBase = row.cells.size() > 1 ? row.cells[1] : "";
        edit.valueOffset = row.cells.size() > 2 ? row.cells[2] : "";
        edit.finalOffset = row.cells.size() > 3 ? row.cells[3] : "";
        std::string config = row.cells.size() > 4 ? row.cells[4] : "";
        parseConfigText(config, edit.doPath, edit.daPath);
        std::string originalConfig = row.originalCells.size() > 4 ? row.originalCells[4] : config;
        parseConfigText(originalConfig, edit.originalDoPath, edit.originalDaPath);
        edit.modified = row.cells != row.originalCells;
        edit.daPath = reverseDaForXml(edit.daPath, edit.valueOffset);
        edit.name = reverseNameFromField(row.cells[8], edit.arrayBase);
        if (!edit.name.empty() || !edit.label.empty()) rows.push_back(std::move(edit));
    }
    std::stable_sort(rows.begin(), rows.end(), [](const ReverseRowEdit& a, const ReverseRowEdit& b) {
        return a.modified && !b.modified;
    });
    return rows;
}

struct ValueNodeRef {
    tinyxml2::XMLElement* element = nullptr;
    std::string topic;
    std::string dataType;
    std::string wiring = "common";
};

void collectValueNodes(tinyxml2::XMLElement* e,
                       std::string topic,
                       std::string dataType,
                       std::string wiring,
                       std::vector<ValueNodeRef>& out) {
    for (; e; e = e->NextSiblingElement()) {
        std::string nodeName = xmlLocalName(e->Name());
        std::string nextTopic = topic;
        std::string nextDataType = dataType;
        std::string nextWiring = wiring;
        if (nodeName == "Topic") nextTopic = xmlAttr(e, "name");
        else if (nodeName == "DataType") nextDataType = xmlAttr(e, "value");
        else if (nodeName == "Sequence") {
            std::string seq = xmlAttr(e, "value");
            if (seq == "7") nextWiring = "star";
            else if (seq == "112") nextWiring = "delta";
        } else if (nodeName == "Value") {
            out.push_back({e, topic, dataType, wiring});
        }
        collectValueNodes(e->FirstChildElement(), nextTopic, nextDataType, nextWiring, out);
    }
}

bool reverseNodeMatches(const ValueNodeRef& node, const ReverseSheetSpec& spec, const ReverseRowEdit& edit) {
    if (node.topic != spec.topic || node.dataType != spec.dataType || !reverseWiringAllowed(node.wiring, spec.wiring)) return false;
    std::string nodeDo = xmlAttr(node.element, "DO");
    std::string nodeDa = xmlAttr(node.element, "DA");
    if (!edit.originalDoPath.empty() && !edit.originalDaPath.empty() &&
        nodeDo == edit.originalDoPath && nodeDa == edit.originalDaPath) {
        return true;
    }
    if (!edit.originalDoPath.empty() && nodeDo == edit.originalDoPath && edit.originalDaPath.empty()) return true;
    std::string nodeName = xmlAttr(node.element, "name");
    std::string nodeDesc = cleanPhaseLabelForReverse(xmlAttr(node.element, "desc"));
    if (!edit.name.empty() && nodeName == edit.name) return true;
    if (!edit.label.empty() && nodeDesc == edit.label) return true;
    return false;
}

std::string generateReverseXml(AppState& app, bool showMessage) {
    commitPreviewEdit(app, true);
    PqToolConfig cfg = readConfig(app.hwnd);
    std::string xmlPath = cfg.xmlPath;
    if (xmlPath.empty() || !fs::exists(fs::u8path(xmlPath))) {
        if (showMessage) MessageBoxW(app.hwnd, L"\x8BF7\x5148\x9009\x62E9\x539F\x59CBXML\x6587\x4EF6\x3002", L"XML\x9006\x751F\x6210", MB_ICONINFORMATION);
        return "";
    }
    if (app.activePreviewSheet < 0 || app.activePreviewSheet >= (int)app.previewSheets.size()) return "";

    tinyxml2::XMLDocument doc;
    std::string xml = readAllText(fs::u8path(xmlPath));
    if (doc.Parse(xml.c_str(), xml.size()) != tinyxml2::XML_SUCCESS) {
        if (showMessage) MessageBoxW(app.hwnd, L"XML\x89E3\x6790\x5931\x8D25\x3002", L"XML\x9006\x751F\x6210", MB_ICONERROR);
        return "";
    }

    ReverseSheetSpec spec = reverseSpecForSheet(app.previewSheets[app.activePreviewSheet].name);
    std::vector<ReverseRowEdit> edits = collectReverseRows(app);
    std::vector<ValueNodeRef> nodes;
    collectValueNodes(doc.RootElement(), "", "", "common", nodes);

    std::set<tinyxml2::XMLElement*> touched;
    int updated = 0;
    for (const auto& edit : edits) {
        for (const auto& node : nodes) {
            if (touched.count(node.element)) continue;
            if (!reverseNodeMatches(node, spec, edit)) continue;
            if (!edit.name.empty()) node.element->SetAttribute("name", edit.name.c_str());
            if (!edit.doPath.empty()) node.element->SetAttribute("DO", edit.doPath.c_str());
            if (!edit.daPath.empty()) node.element->SetAttribute("DA", edit.daPath.c_str());
            if (!edit.finalOffset.empty()) node.element->SetAttribute("Offset", edit.finalOffset.c_str());
            touched.insert(node.element);
            ++updated;
            break;
        }
    }

    tinyxml2::XMLPrinter printer;
    doc.Print(&printer);
    app.generatedXmlText = printer.CStr();
    app.generatedXmlSourcePath = xmlPath;
    app.reverseXmlDirty = false;
    updateXmlPreviewText(app);
    if (showMessage) {
        MessageBoxW(app.hwnd, u8w("XML逆生成完成，更新配置项: " + std::to_string(updated)).c_str(),
                    L"XML\x9006\x751F\x6210", MB_ICONINFORMATION);
    }
    return app.generatedXmlText;
}

void runReverseXml(AppState& app) {
    if (!generateReverseXml(app, true).empty()) selectPage(app, 4);
}

void runExportXml(AppState& app) {
    if (app.generatedXmlText.empty() || app.reverseXmlDirty) generateReverseXml(app, false);
    if (app.generatedXmlText.empty()) return;
    std::string out;
    if (!saveFileDialog(app.hwnd, L"\x5BFC\x51FAXML", L"XML Files\0*.xml;*.icd\0All Files\0*.*\0", L"xml", out)) return;
    std::ofstream ofs(fs::u8path(out), std::ios::binary);
    ofs << app.generatedXmlText;
    appendLog(app, "XML exported: " + out);
}

void autoParseTraceDir(AppState& app, const std::string& traceDir, const char* reason) {
    if (traceDir.empty()) {
        autoParseAndRefresh(app, reason);
        return;
    }

    fs::path dir = fs::u8path(traceDir);
    PqToolConfig cfg = readConfig(app.hwnd);
    std::string xmlPath;
    std::string outputPath = (dir / "final_sorted.xls").u8string();
    std::string frontType = selectedFrontType(app);

    fs::path contextPath = dir / "trace_context.json";
    if (fs::exists(contextPath)) {
        try {
            json context = json::parse(readAllText(contextPath));
            auto readString = [&](const char* key) -> std::string {
                auto it = context.find(key);
                return it == context.end() ? "" : jsonScalarString(*it);
            };
            std::string fromContext = readString("xmlPath");
            if (!fromContext.empty()) xmlPath = fromContext;
            fromContext = readString("outputPath");
            if (!fromContext.empty()) outputPath = fromContext;
            fromContext = readString("frontType");
            if (!fromContext.empty()) frontType = fromContext;
        } catch (...) {
        }
    }

    if (xmlPath.empty() && sameTraceDir(traceDir, app.activeTraceDir)) xmlPath = cfg.xmlPath;
    if (xmlPath.empty()) {
        appendLog(app, "Auto parse skipped: missing XML for " + traceDir);
        return;
    }

    std::vector<std::string> jsonPaths = collectJsonDataFiles(dir);
    std::vector<std::string> originPaths = collectOriginFiles(dir);
    std::string err;
    std::string reasonText = reason ? reason : "";
    BusyPopupGuard busy(app,
                        reasonText == "data" || reasonText == "trace",
                        L"\u6570\u636E\u5230\u8FBE\uFF0C\u6B63\u5728\u5199\u5165\u8868\u683C...");
    bool ok = pqRunParser(xmlPath, jsonPaths, originPaths, outputPath, &err, frontType);
    bool active = sameTraceDir(traceDir, app.activeTraceDir);
    if (ok) {
        if (active) {
            setText(app.hwnd, IDC_XML_PATH, xmlPath);
            setText(app.hwnd, IDC_JSON_PATH, joinPaths(jsonPaths));
            setText(app.hwnd, IDC_ORIGIN_PATHS, joinPaths(originPaths));
            setText(app.hwnd, IDC_OUTPUT_PATH, outputPath);
            refreshPreviewWorkbookChoices(app, outputPath);
            refreshPreviewFromWorkbook(app, outputPath);
        }
        appendLog(app, std::string("Auto parse updated(") + (reason ? reason : "mq") + "): " + outputPath);
    } else {
        if (active && app.previewStatus) SetWindowTextW(app.previewStatus, u8w("Auto parse failed: " + err).c_str());
        appendLog(app, "Auto parse failed: " + err);
    }
}

void autoParseAndRefresh(AppState& app, const char* reason) {
    PqToolConfig cfg = readConfig(app.hwnd);
    std::vector<std::string> jsonPaths = cfg.jsonDataPaths.empty() ? splitPathList(cfg.jsonDataPath) : cfg.jsonDataPaths;
    std::string err;
    std::string reasonText = reason ? reason : "";
    BusyPopupGuard busy(app,
                        reasonText == "data" || reasonText == "trace",
                        L"\u6570\u636E\u5230\u8FBE\uFF0C\u6B63\u5728\u5199\u5165\u8868\u683C...");
    bool ok = pqRunParser(cfg.xmlPath, jsonPaths, cfg.originPaths, cfg.outputPath, &err, selectedFrontType(app));
    if (ok) {
        refreshPreviewWorkbookChoices(app, cfg.outputPath);
        refreshPreviewFromWorkbook(app, cfg.outputPath);
        appendLog(app, std::string("Auto parse updated(") + (reason ? reason : "mq") + "): " + cfg.outputPath);
    } else {
        if (app.previewStatus) SetWindowTextW(app.previewStatus, u8w("Auto parse failed: " + err).c_str());
        appendLog(app, "Auto parse failed: " + err);
    }
}

void createConfigPage(AppState& app) {
    PqToolConfig cfg = pqDefaultConfig();
    HWND p = app.pageConfig;
    addLabel(app, p, L"配置项", 22, 10, 120, 26);
    const int groupX = 18, groupW = 1110, rowGap = 32, x1 = 38, x2 = 520, x3 = 810;

    addGroup(app, p, L"前置配置", groupX, 42, groupW, 82);
    addLabeledEdit(app, p, L"FrontInst", IDC_FRONT_INST, cfg.frontInst, x1, 74, 118, 330);
    addLabeledEdit(app, p, L"FrontIP", IDC_FRONT_IP, cfg.frontIp, x2, 74, 90, 180);

    addGroup(app, p, L"台账配置", groupX, 136, groupW, 82);
    addLabeledEdit(app, p, L"TerminalStatus", IDC_TERMINAL_STATUS, cfg.terminalStatus, x1, 168, 118, 140);
    addLabeledEdit(app, p, L"MonitorStatus", IDC_MONITOR_STATUS, cfg.monitorStatus, x2, 168, 118, 140);
    addLabeledEdit(app, p, L"IcdFlag", IDC_ICD_FLAG, cfg.icdFlag, x3, 168, 70, 80);

    addGroup(app, p, L"接口配置", groupX, 230, groupW, 122);
    addLabeledEdit(app, p, L"WebDevice", IDC_WEB_DEVICE, cfg.webDevice, x1, 262, 118, 520);
    addLabeledEdit(app, p, L"WebIcd", IDC_WEB_ICD, cfg.webIcd, x3, 262, 90, 225);
    addLabeledEdit(app, p, L"WebFiledownload", IDC_WEB_FILEDOWNLOAD, cfg.webFiledownload, x1, 296, 118, 520);
    addLabeledEdit(app, p, L"XML目录", IDC_XML_SAVE_DIR, cfg.xmlSaveDir, x3, 296, 90, 225);

    addGroup(app, p, L"MQ配置", groupX, 364, groupW, 316);
    addLabel(app, p, L"生产者", x1, 398, 80, 22);
    addLabeledEdit(app, p, L"producer", IDC_PRODUCER, cfg.producer, 120, 398, 90, 300);
    addLabeledEdit(app, p, L"Ipport", IDC_IPPORT, cfg.ipport, 600, 398, 80, 260);
    addLabeledEdit(app, p, L"AccessKey", IDC_PRODUCER_ACCESS_KEY, cfg.producerAccessKey, 120, 398 + rowGap, 90, 300);
    addLabeledEdit(app, p, L"SecretKey", IDC_PRODUCER_SECRET_KEY, cfg.producerSecretKey, 600, 398 + rowGap, 80, 260);
    addLabeledEdit(app, p, L"TopicLOG", IDC_TOPIC_LOG, cfg.topicLOG, 120, 398 + rowGap * 2, 90, 360);
    addLabeledEdit(app, p, L"TagLOG", IDC_TAG_LOG, cfg.tagLOG, 575, 398 + rowGap * 2, 75, 270);
    addLabeledEdit(app, p, L"KeyLOG", IDC_KEY_LOG, cfg.keyLOG, 940, 398 + rowGap * 2, 70, 120);

    addLabel(app, p, L"消费者", x1, 512, 80, 22);
    addLabeledEdit(app, p, L"consumer", IDC_CONSUMER, cfg.consumer, 120, 512, 90, 300);
    addLabeledEdit(app, p, L"Ipport", IDC_CONSUMER_IPPORT, cfg.consumerIpport, 600, 512, 80, 260);
    addLabeledEdit(app, p, L"AccessKey", IDC_CONSUMER_ACCESS_KEY, cfg.consumerAccessKey, 120, 512 + rowGap, 90, 300);
    addLabeledEdit(app, p, L"SecretKey", IDC_CONSUMER_SECRET_KEY, cfg.consumerSecretKey, 600, 512 + rowGap, 80, 260);
    addLabeledEdit(app, p, L"\x7EDF\x8BA1Topic", IDC_DATA_STAT_TOPIC, cfg.dataStatTopic, 120, 512 + rowGap * 2, 90, 360);
    addLabeledEdit(app, p, L"DATATag", IDC_DATA_STAT_TAG, cfg.dataStatTag, 575, 512 + rowGap * 2, 75, 270);
    addLabeledEdit(app, p, L"DATAKey", IDC_DATA_STAT_KEY, cfg.dataStatKey, 940, 512 + rowGap * 2, 70, 120);
    addLabeledEdit(app, p, L"\x5B9E\x65F6Topic", IDC_DATA_REALTIME_TOPIC, cfg.dataRealtimeTopic, 120, 512 + rowGap * 3, 90, 360);
    addLabeledEdit(app, p, L"DATATag", IDC_DATA_REALTIME_TAG, cfg.dataRealtimeTag, 575, 512 + rowGap * 3, 75, 270);
    addLabeledEdit(app, p, L"DATAKey", IDC_DATA_REALTIME_KEY, cfg.dataRealtimeKey, 940, 512 + rowGap * 3, 70, 120);
    addLabeledEdit(app, p, L"TraceTopic", IDC_TRACE_TOPIC, cfg.traceTopic, 120, 512 + rowGap * 4, 90, 360);
    addLabeledEdit(app, p, L"TraceTag", IDC_TRACE_TAG, cfg.traceTag, 575, 512 + rowGap * 4, 75, 270);
    addLabeledEdit(app, p, L"TraceKey", IDC_TRACE_KEY, cfg.traceKey, 940, 512 + rowGap * 4, 70, 120);
}

void createLedgerPage(AppState& app) {
    PqToolConfig cfg = pqDefaultConfig();
    HWND p = app.pageLedger;
    int y = 16;
    addLabeledEdit(app, p, L"XML文件", IDC_XML_PATH, cfg.xmlPath, 18, y, 70, 670);
    addButton(app, p, IDC_BROWSE_XML, L"选择XML", 780, y - 1, 90, 25);
    addLabeledEdit(app, p, L"输出", IDC_OUTPUT_PATH, cfg.outputPath, 890, y, 48, 235);
    y += 34;
    addLabel(app, p, L"jsondata", 18, y, 70, 24);
    addMemo(app, p, IDC_JSON_PATH, 88, y, 670, 52);
    setText(p, IDC_JSON_PATH, cfg.jsonDataPath);
    addButton(app, p, IDC_BROWSE_JSON, L"添加JSON", 780, y - 1, 90, 25);
    y += 66;
    addLabel(app, p, L"origin", 18, y, 70, 24);
    addMemo(app, p, IDC_ORIGIN_PATHS, 88, y, 670, 56);
    setText(p, IDC_ORIGIN_PATHS, "origin.txt");
    addButton(app, p, IDC_ADD_ORIGIN, L"添加origin", 780, y - 1, 90, 25);

    y += 70;
    addLabel(app, p, L"进程类型", 18, y, 70, 24);
    app.frontType = CreateWindowExW(0, L"COMBOBOX", L"", WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | WS_TABSTOP,
                                    88, y, 150, 120, p, (HMENU)(INT_PTR)IDC_FRONT_TYPE, app.inst, nullptr);
    applyFont(app, app.frontType);
    SendMessageW(app.frontType, CB_ADDSTRING, 0, (LPARAM)L"cfg_stat_data");
    SendMessageW(app.frontType, CB_ADDSTRING, 0, (LPARAM)L"cfg_3s_data");
    SendMessageW(app.frontType, CB_SETCURSEL, 0, 0);
    addButton(app, p, IDC_GET_LEDGER, L"获取台账", 260, y - 1, 100, 26);
    addButton(app, p, IDC_INIT_MQ, L"初始化MQ", 375, y - 1, 100, 26);
    addButton(app, p, IDC_TRACE, L"数据追踪", 490, y - 1, 100, 26);
    addButton(app, p, IDC_PARSE, L"一键解析", 605, y - 1, 100, 26);

    int panelY = y + 42;
    app.tree = CreateWindowExW(WS_EX_CLIENTEDGE, WC_TREEVIEWW, L"",
                               WS_CHILD | WS_VISIBLE | WS_TABSTOP | TVS_HASLINES | TVS_LINESATROOT | TVS_HASBUTTONS,
                               18, panelY, 430, 455, p, (HMENU)(INT_PTR)IDC_TREE, app.inst, nullptr);
    applyFont(app, app.tree);
    app.detail = addMemo(app, p, IDC_DETAIL, 465, panelY, 670, 155);
    SendMessageW(app.detail, EM_SETREADONLY, TRUE, 0);
    app.log = addMemo(app, p, IDC_LOG, 465, panelY + 170, 670, 285);
    SendMessageW(app.log, EM_SETREADONLY, TRUE, 0);
    updateDetails(app);
    appendLogW(app, L"工具已启动。无参数运行显示界面；带 XML 参数运行原命令行解析。");
}

void createJsonPage(AppState& app) {
    HWND p = app.pageJson;
    addLabel(app, p, L"\x6D4B\x70B9", 18, 14, 50, 24);
    app.jsonMonitor = CreateWindowExW(0, L"COMBOBOX", L"", WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | WS_TABSTOP,
                                      70, 12, 500, 320, p, (HMENU)(INT_PTR)IDC_JSON_MONITOR, app.inst, nullptr);
    applyFont(app, app.jsonMonitor);
    addLabel(app, p, L"JSON\x8BB0\x5F55", 18, 50, 130, 24);
    addLabel(app, p, L"JSON\x8BE6\x60C5", 385, 50, 130, 24);
    app.jsonTree = CreateWindowExW(WS_EX_CLIENTEDGE, WC_TREEVIEWW, L"",
                                   WS_CHILD | WS_VISIBLE | WS_TABSTOP |
                                       TVS_HASLINES | TVS_LINESATROOT | TVS_HASBUTTONS,
                                   18, 80, 345, 555, p, (HMENU)(INT_PTR)IDC_JSON_TREE, app.inst, nullptr);
    applyFont(app, app.jsonTree);
    app.jsonDetail = addMemo(app, p, IDC_JSON_DETAIL, 385, 80, 750, 555);
    SendMessageW(app.jsonDetail, EM_SETREADONLY, TRUE, 0);
    refreshJsonMonitorChoices(app, app.activeTraceDir);
    rebuildJsonTree(app);
    updateJsonDetail(app);
}

void addPreviewColumn(HWND list, int index, const wchar_t* text, int width) {
    LVCOLUMNW col{};
    col.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
    col.pszText = const_cast<wchar_t*>(text);
    col.cx = width;
    col.iSubItem = index;
    ListView_InsertColumn(list, index, &col);
}

void createPreviewPage(AppState& app) {
    HWND p = app.pagePreview;
    addLabel(app, p, L"\x6D4B\x70B9", 18, 14, 42, 24);
    app.previewWorkbook = CreateWindowExW(0, L"COMBOBOX", L"", WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | WS_TABSTOP,
                                          60, 12, 245, 320, p, (HMENU)(INT_PTR)IDC_PREVIEW_WORKBOOK, app.inst, nullptr);
    applyFont(app, app.previewWorkbook);
    addLabel(app, p, L"Sheet", 315, 14, 45, 24);
    app.previewSheet = CreateWindowExW(0, L"COMBOBOX", L"", WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | WS_TABSTOP,
                                       360, 12, 150, 360, p, (HMENU)(INT_PTR)IDC_PREVIEW_SHEET, app.inst, nullptr);
    applyFont(app, app.previewSheet);
    addLabel(app, p, L"\x7B5B\x9009", 520, 14, 42, 24);
    app.previewFilter = CreateWindowExW(0, L"COMBOBOX", L"", WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | WS_TABSTOP,
                                        565, 12, 100, 160, p, (HMENU)(INT_PTR)IDC_PREVIEW_FILTER, app.inst, nullptr);
    applyFont(app, app.previewFilter);
    SendMessageW(app.previewFilter, CB_ADDSTRING, 0, (LPARAM)L"\x5168\x90E8");
    SendMessageW(app.previewFilter, CB_ADDSTRING, 0, (LPARAM)L"\x6B63\x5E38");
    SendMessageW(app.previewFilter, CB_ADDSTRING, 0, (LPARAM)L"\x5F02\x5E38");
    SendMessageW(app.previewFilter, CB_ADDSTRING, 0, (LPARAM)L"\x7F3A\x5931");
    SendMessageW(app.previewFilter, CB_ADDSTRING, 0, (LPARAM)L"\x7A7A\x767D");
    SendMessageW(app.previewFilter, CB_SETCURSEL, 0, 0);
    addLabel(app, p, L"\x76F8\x4F4D", 675, 14, 42, 24);
    app.previewPhase = CreateWindowExW(0, L"COMBOBOX", L"", WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | WS_TABSTOP,
                                       720, 12, 70, 160, p, (HMENU)(INT_PTR)IDC_PREVIEW_PHASE, app.inst, nullptr);
    applyFont(app, app.previewPhase);
    SendMessageW(app.previewPhase, CB_ADDSTRING, 0, (LPARAM)L"\x5168\x90E8");
    SendMessageW(app.previewPhase, CB_ADDSTRING, 0, (LPARAM)L"A");
    SendMessageW(app.previewPhase, CB_ADDSTRING, 0, (LPARAM)L"B");
    SendMessageW(app.previewPhase, CB_ADDSTRING, 0, (LPARAM)L"C");
    SendMessageW(app.previewPhase, CB_ADDSTRING, 0, (LPARAM)L"T");
    SendMessageW(app.previewPhase, CB_SETCURSEL, 0, 0);
    addLabel(app, p, L"\x7F29\x653E", 800, 14, 42, 24);
    app.previewZoom = CreateWindowExW(0, L"COMBOBOX", L"", WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | WS_TABSTOP,
                                      845, 12, 75, 160, p, (HMENU)(INT_PTR)IDC_PREVIEW_ZOOM, app.inst, nullptr);
    applyFont(app, app.previewZoom);
    SendMessageW(app.previewZoom, CB_ADDSTRING, 0, (LPARAM)L"80%");
    SendMessageW(app.previewZoom, CB_ADDSTRING, 0, (LPARAM)L"100%");
    SendMessageW(app.previewZoom, CB_ADDSTRING, 0, (LPARAM)L"125%");
    SendMessageW(app.previewZoom, CB_ADDSTRING, 0, (LPARAM)L"150%");
    SendMessageW(app.previewZoom, CB_SETCURSEL, 1, 0);
    app.importIcd = addButton(app, p, IDC_IMPORT_ICD, L"\x5BFC\x5165icd", 930, 12, 95, 26);
    app.reverseXml = addButton(app, p, IDC_REVERSE_XML, L"xml\x9006\x751F\x6210", 1035, 12, 100, 26);
    addLabel(app, p, L"\x641C\x7D22", 18, 47, 42, 24);
    app.previewSearch = addEdit(app, p, IDC_PREVIEW_SEARCH, "", 60, 45, 360, 26);
    app.previewStatus = nullptr;
    app.previewList = CreateWindowExW(WS_EX_CLIENTEDGE, WC_LISTVIEWW, L"",
                                      WS_CHILD | WS_VISIBLE | WS_TABSTOP | LVS_REPORT | LVS_SHOWSELALWAYS,
                                      18, 78, 1115, 557, p, (HMENU)(INT_PTR)IDC_PREVIEW_LIST, app.inst, nullptr);
    updatePreviewFont(app);
    ListView_SetExtendedListViewStyle(app.previewList, LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES);
    resetPreviewColumns(app.previewList, 12);
    refreshPreviewWorkbookChoices(app, "");
}

void createXmlPreviewPage(AppState& app) {
    HWND p = app.pageXmlPreview;
    addButton(app, p, IDC_EXPORT_XML, L"\x5BFC\x51FAxml", 18, 12, 110, 28);
    addButton(app, p, IDC_XML_SEARCH_BUTTON, L"\x641C\x7D22", 150, 12, 70, 28);
    app.xmlSearch = addEdit(app, p, IDC_XML_SEARCH, "", 230, 12, 360, 28);
    app.xmlPreview = CreateWindowExW(WS_EX_CLIENTEDGE, L"EDIT", L"",
                                     WS_CHILD | WS_VISIBLE | WS_TABSTOP | ES_MULTILINE |
                                         ES_AUTOVSCROLL | ES_AUTOHSCROLL | ES_NOHIDESEL |
                                         WS_VSCROLL | WS_HSCROLL,
                                     18, 50, 1115, 585, p,
                                     (HMENU)(INT_PTR)IDC_XML_PREVIEW_EDIT, app.inst, nullptr);
    app.xmlFont = CreateFontW(-15, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE,
                              DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                              CLEARTYPE_QUALITY, FIXED_PITCH | FF_MODERN, L"Consolas");
    SendMessageW(app.xmlPreview, WM_SETFONT, (WPARAM)(app.xmlFont ? app.xmlFont : app.font), TRUE);
    SendMessageW(app.xmlPreview, EM_SETREADONLY, TRUE, 0);
}

void createConfigPageClean(AppState& app) {
    PqToolConfig cfg = pqDefaultConfig();
    HWND p = app.pageConfig;
    const int groupX = 18, groupW = 1110, rowGap = 32, x1 = 38, x2 = 520, x3 = 810;
    const int mqNameX = 38, mqFieldX = 160, mqTopicW = 310, mqTagX = 575, mqTagW = 250, mqKeyX = 930, mqKeyW = 120;

    addLabel(app, p, L"\x914D\x7F6E\x9879", 22, 10, 120, 26);

    addGroup(app, p, L"\x524D\x7F6E\x914D\x7F6E", groupX, 42, groupW, 82);
    addLabeledEdit(app, p, L"FrontInst", IDC_FRONT_INST, cfg.frontInst, x1, 74, 118, 330);
    addLabeledEdit(app, p, L"FrontIP", IDC_FRONT_IP, cfg.frontIp, x2, 74, 90, 180);

    addGroup(app, p, L"\x53F0\x8D26\x914D\x7F6E", groupX, 136, groupW, 82);
    addLabeledEdit(app, p, L"TerminalStatus", IDC_TERMINAL_STATUS, cfg.terminalStatus, x1, 168, 118, 140);
    addLabeledEdit(app, p, L"MonitorStatus", IDC_MONITOR_STATUS, cfg.monitorStatus, x2, 168, 118, 140);
    addLabeledEdit(app, p, L"IcdFlag", IDC_ICD_FLAG, cfg.icdFlag, x3, 168, 70, 80);

    addGroup(app, p, L"\x63A5\x53E3\x914D\x7F6E", groupX, 230, groupW, 122);
    addLabeledEdit(app, p, L"WebDevice", IDC_WEB_DEVICE, cfg.webDevice, x1, 262, 118, 520);
    addLabeledEdit(app, p, L"WebIcd", IDC_WEB_ICD, cfg.webIcd, x3, 262, 90, 225);
    addLabeledEdit(app, p, L"WebFiledownload", IDC_WEB_FILEDOWNLOAD, cfg.webFiledownload, x1, 296, 118, 520);
    addLabeledEdit(app, p, L"XML\x76EE\x5F55", IDC_XML_SAVE_DIR, cfg.xmlSaveDir, x3, 296, 90, 225);

    addGroup(app, p, L"MQ\x914D\x7F6E", groupX, 364, groupW, 316);
    addLabel(app, p, L"\x751F\x4EA7\x8005", mqNameX, 398, 90, 22);
    addLabeledEdit(app, p, L"producer", IDC_PRODUCER, cfg.producer, mqFieldX, 398, 90, 300);
    addLabeledEdit(app, p, L"Ipport", IDC_IPPORT, cfg.ipport, mqTagX, 398, 80, 260);
    addLabeledEdit(app, p, L"AccessKey", IDC_PRODUCER_ACCESS_KEY, cfg.producerAccessKey, mqFieldX, 398 + rowGap, 90, 300);
    addLabeledEdit(app, p, L"SecretKey", IDC_PRODUCER_SECRET_KEY, cfg.producerSecretKey, mqTagX, 398 + rowGap, 80, 260);
    addLabeledEdit(app, p, L"TopicLOG", IDC_TOPIC_LOG, cfg.topicLOG, mqFieldX, 398 + rowGap * 2, 90, mqTopicW);
    addLabeledEdit(app, p, L"TagLOG", IDC_TAG_LOG, cfg.tagLOG, mqTagX, 398 + rowGap * 2, 75, mqTagW);
    addLabeledEdit(app, p, L"KeyLOG", IDC_KEY_LOG, cfg.keyLOG, mqKeyX, 398 + rowGap * 2, 70, mqKeyW);

    addLabel(app, p, L"\x6D88\x8D39\x8005", mqNameX, 512, 90, 22);
    addLabeledEdit(app, p, L"consumer", IDC_CONSUMER, cfg.consumer, mqFieldX, 512, 90, 300);
    addLabeledEdit(app, p, L"Ipport", IDC_CONSUMER_IPPORT, cfg.consumerIpport, mqTagX, 512, 80, 260);
    addLabeledEdit(app, p, L"AccessKey", IDC_CONSUMER_ACCESS_KEY, cfg.consumerAccessKey, mqFieldX, 512 + rowGap, 90, 300);
    addLabeledEdit(app, p, L"SecretKey", IDC_CONSUMER_SECRET_KEY, cfg.consumerSecretKey, mqTagX, 512 + rowGap, 80, 260);
    addLabeledEdit(app, p, L"\x7EDF\x8BA1Topic", IDC_DATA_STAT_TOPIC, cfg.dataStatTopic, mqFieldX, 512 + rowGap * 2, 90, mqTopicW);
    addLabeledEdit(app, p, L"DATATag", IDC_DATA_STAT_TAG, cfg.dataStatTag, mqTagX, 512 + rowGap * 2, 75, mqTagW);
    addLabeledEdit(app, p, L"DATAKey", IDC_DATA_STAT_KEY, cfg.dataStatKey, mqKeyX, 512 + rowGap * 2, 70, mqKeyW);
    addLabeledEdit(app, p, L"\x5B9E\x65F6Topic", IDC_DATA_REALTIME_TOPIC, cfg.dataRealtimeTopic, mqFieldX, 512 + rowGap * 3, 90, mqTopicW);
    addLabeledEdit(app, p, L"DATATag", IDC_DATA_REALTIME_TAG, cfg.dataRealtimeTag, mqTagX, 512 + rowGap * 3, 75, mqTagW);
    addLabeledEdit(app, p, L"DATAKey", IDC_DATA_REALTIME_KEY, cfg.dataRealtimeKey, mqKeyX, 512 + rowGap * 3, 70, mqKeyW);
    addLabeledEdit(app, p, L"TraceTopic", IDC_TRACE_TOPIC, cfg.traceTopic, mqFieldX, 512 + rowGap * 4, 90, mqTopicW);
    addLabeledEdit(app, p, L"TraceTag", IDC_TRACE_TAG, cfg.traceTag, mqTagX, 512 + rowGap * 4, 75, mqTagW);
    addLabeledEdit(app, p, L"TraceKey", IDC_TRACE_KEY, cfg.traceKey, mqKeyX, 512 + rowGap * 4, 70, mqKeyW);
}

void createLedgerPageClean(AppState& app) {
    PqToolConfig cfg = pqDefaultConfig();
    HWND p = app.pageLedger;
    int y = 16;
    addLabeledEdit(app, p, L"XML\x6587\x4EF6", IDC_XML_PATH, cfg.xmlPath, 18, y, 70, 670);
    addButton(app, p, IDC_BROWSE_XML, L"\x9009\x62E9XML", 780, y - 1, 90, 25);
    addLabeledEdit(app, p, L"\x8F93\x51FA", IDC_OUTPUT_PATH, cfg.outputPath, 890, y, 48, 235);
    y += 34;
    addLabel(app, p, L"jsondata", 18, y, 70, 24);
    addMemo(app, p, IDC_JSON_PATH, 88, y, 670, 52);
    setText(p, IDC_JSON_PATH, cfg.jsonDataPath);
    addButton(app, p, IDC_BROWSE_JSON, L"\x6DFB\x52A0JSON", 780, y - 1, 90, 25);
    y += 66;
    addLabel(app, p, L"origin", 18, y, 70, 24);
    addMemo(app, p, IDC_ORIGIN_PATHS, 88, y, 670, 56);
    setText(p, IDC_ORIGIN_PATHS, "origin.txt");
    addButton(app, p, IDC_ADD_ORIGIN, L"\x6DFB\x52A0origin", 780, y - 1, 90, 25);

    y += 70;
    addLabel(app, p, L"\x8FDB\x7A0B\x7C7B\x578B", 18, y, 70, 24);
    app.frontType = CreateWindowExW(0, L"COMBOBOX", L"", WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | WS_TABSTOP,
                                    88, y, 150, 120, p, (HMENU)(INT_PTR)IDC_FRONT_TYPE, app.inst, nullptr);
    applyFont(app, app.frontType);
    SendMessageW(app.frontType, CB_ADDSTRING, 0, (LPARAM)L"cfg_stat_data");
    SendMessageW(app.frontType, CB_ADDSTRING, 0, (LPARAM)L"cfg_3s_data");
    SendMessageW(app.frontType, CB_SETCURSEL, 0, 0);
    addButton(app, p, IDC_GET_LEDGER, L"\x83B7\x53D6\x53F0\x8D26", 260, y - 1, 100, 26);
    addButton(app, p, IDC_INIT_MQ, L"\x521D\x59CB\x5316MQ", 375, y - 1, 100, 26);
    addButton(app, p, IDC_TRACE, L"\x6570\x636E\x8FFD\x8E2A", 490, y - 1, 100, 26);
    addButton(app, p, IDC_PARSE, L"\x4E00\x952E\x89E3\x6790", 605, y - 1, 100, 26);

    int panelY = y + 42;
    app.tree = CreateWindowExW(WS_EX_CLIENTEDGE, WC_TREEVIEWW, L"",
                               WS_CHILD | WS_VISIBLE | WS_TABSTOP | TVS_HASLINES | TVS_LINESATROOT | TVS_HASBUTTONS,
                               18, panelY, 430, 430, p, (HMENU)(INT_PTR)IDC_TREE, app.inst, nullptr);
    applyFont(app, app.tree);
    app.detail = addMemo(app, p, IDC_DETAIL, 465, panelY, 670, 150);
    SendMessageW(app.detail, EM_SETREADONLY, TRUE, 0);
    app.log = addMemo(app, p, IDC_LOG, 465, panelY + 165, 670, 265);
    SendMessageW(app.log, EM_SETREADONLY, TRUE, 0);
    updateDetails(app);
    appendLogW(app, L"\x5DE5\x5177\x5DF2\x542F\x52A8\x3002");
}

void createUi(AppState& app) {
    app.font = CreateFontW(-16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE,
                           DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
                           CLEARTYPE_QUALITY, DEFAULT_PITCH | FF_SWISS, L"Microsoft YaHei UI");
    app.ownsFont = app.font != nullptr;
    if (!app.font) app.font = (HFONT)GetStockObject(DEFAULT_GUI_FONT);
    app.tab = CreateWindowExW(0, WC_TABCONTROLW, L"", WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_TABSTOP,
                              10, 10, 1170, 735, app.hwnd, (HMENU)(INT_PTR)IDC_TAB, app.inst, nullptr);
    applyFont(app, app.tab);

    TCITEMW item{};
    item.mask = TCIF_TEXT;
    item.pszText = const_cast<wchar_t*>(L"配置项");
    SendMessageW(app.tab, TCM_INSERTITEMW, 0, (LPARAM)&item);
    item.pszText = const_cast<wchar_t*>(L"台账列表");
    SendMessageW(app.tab, TCM_INSERTITEMW, 1, (LPARAM)&item);
    item.pszText = const_cast<wchar_t*>(L"JSON\x8BE6\x60C5");
    SendMessageW(app.tab, TCM_INSERTITEMW, 2, (LPARAM)&item);
    item.pszText = const_cast<wchar_t*>(L"\x8868\x683C\x9884\x89C8");
    SendMessageW(app.tab, TCM_INSERTITEMW, 3, (LPARAM)&item);
    item.pszText = const_cast<wchar_t*>(L"XML\x9884\x89C8");
    SendMessageW(app.tab, TCM_INSERTITEMW, 4, (LPARAM)&item);
    item.pszText = const_cast<wchar_t*>(L"\x914D\x7F6E\x9879");
    SendMessageW(app.tab, TCM_SETITEMW, 0, (LPARAM)&item);
    item.pszText = const_cast<wchar_t*>(L"\x53F0\x8D26\x5217\x8868");
    SendMessageW(app.tab, TCM_SETITEMW, 1, (LPARAM)&item);
    SendMessageW(app.tab, TCM_SETITEMSIZE, 0, MAKELPARAM(150, 34));

    app.pageConfig = CreateWindowExW(0, L"PqToolPanel", L"", WS_CHILD | WS_VISIBLE,
                                     20, 52, 1150, 680, app.hwnd, (HMENU)(INT_PTR)IDC_PAGE_CONFIG, app.inst, nullptr);
    app.pageLedger = CreateWindowExW(0, L"PqToolPanel", L"", WS_CHILD,
                                     20, 52, 1150, 680, app.hwnd, (HMENU)(INT_PTR)IDC_PAGE_LEDGER, app.inst, nullptr);
    app.pageJson = CreateWindowExW(0, L"PqToolPanel", L"", WS_CHILD,
                                   20, 52, 1150, 680, app.hwnd, (HMENU)(INT_PTR)IDC_PAGE_JSON, app.inst, nullptr);
    app.pagePreview = CreateWindowExW(0, L"PqToolPanel", L"", WS_CHILD,
                                      20, 52, 1150, 680, app.hwnd, (HMENU)(INT_PTR)IDC_PAGE_PREVIEW, app.inst, nullptr);
    app.pageXmlPreview = CreateWindowExW(0, L"PqToolPanel", L"", WS_CHILD,
                                         20, 52, 1150, 680, app.hwnd, (HMENU)(INT_PTR)IDC_PAGE_XML_PREVIEW, app.inst, nullptr);
    createConfigPageClean(app);
    createLedgerPageClean(app);
    createJsonPage(app);
    createPreviewPage(app);
    createXmlPreviewPage(app);
    showPage(app, 0);
}

LRESULT CALLBACK wndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
    AppState& app = *g_app;
    switch (msg) {
    case WM_PQ_MQ_EVENT: {
        std::unique_ptr<PqMqEvent> ev(reinterpret_cast<PqMqEvent*>(lp));
        if (ev) addJsonEvent(app, *ev);
        return 0;
    }
    case WM_PQ_START_PREVIEW_EDIT:
        startPreviewEdit(app, static_cast<int>(wp), static_cast<int>(lp));
        return 0;
    case WM_CREATE:
        app.hwnd = hwnd;
        createUi(app);
        return 0;
    case WM_COMMAND:
        if (LOWORD(wp) == IDC_PREVIEW_FILTER && HIWORD(wp) == CBN_SELCHANGE) {
            int idx = (int)SendMessageW(app.previewFilter, CB_GETCURSEL, 0, 0);
            int filters[] = {-1, 1, 2, 3, 0};
            app.previewStatusFilter = (idx >= 0 && idx < 5) ? filters[idx] : -1;
            populatePreviewList(app);
            return 0;
        }
        if (LOWORD(wp) == IDC_PREVIEW_PHASE && HIWORD(wp) == CBN_SELCHANGE) {
            int idx = (int)SendMessageW(app.previewPhase, CB_GETCURSEL, 0, 0);
            const char* phases[] = {"", "A", "B", "C", "T"};
            app.previewPhaseFilter = (idx >= 0 && idx < 5) ? phases[idx] : "";
            populatePreviewList(app);
            return 0;
        }
        if (LOWORD(wp) == IDC_PREVIEW_SEARCH && HIWORD(wp) == EN_CHANGE) {
            app.previewSearchText = getText(hwnd, IDC_PREVIEW_SEARCH);
            populatePreviewList(app);
            return 0;
        }
        if (LOWORD(wp) == IDC_XML_SEARCH && HIWORD(wp) == EN_CHANGE) {
            app.xmlSearchText = getText(hwnd, IDC_XML_SEARCH);
            app.xmlSearchLastText.clear();
            app.xmlSearchNextPos = 0;
            highlightXmlSearch(app, false, false);
            return 0;
        }
        if (LOWORD(wp) == IDC_XML_SEARCH_BUTTON && HIWORD(wp) == BN_CLICKED) {
            app.xmlSearchText = getText(hwnd, IDC_XML_SEARCH);
            if (app.reverseXmlDirty || app.generatedXmlText.empty()) {
                generateReverseXml(app, false);
                app.xmlSearchLastText.clear();
                app.xmlSearchNextPos = 0;
                updateXmlPreviewText(app);
            }
            highlightXmlSearch(app, true, true);
            return 0;
        }
        if (LOWORD(wp) == IDC_PREVIEW_CELL_EDIT && HIWORD(wp) == EN_KILLFOCUS) {
            commitPreviewEdit(app, true);
            return 0;
        }
        if (LOWORD(wp) == IDC_PREVIEW_ZOOM && HIWORD(wp) == CBN_SELCHANGE) {
            int idx = (int)SendMessageW(app.previewZoom, CB_GETCURSEL, 0, 0);
            int zooms[] = {80, 100, 125, 150};
            if (idx >= 0 && idx < 4) app.previewZoomPercent = zooms[idx];
            updatePreviewFont(app);
            populatePreviewList(app);
            return 0;
        }
        if (LOWORD(wp) == IDC_PREVIEW_WORKBOOK && HIWORD(wp) == CBN_SELCHANGE) {
            int idx = (int)SendMessageW(app.previewWorkbook, CB_GETCURSEL, 0, 0);
            if (idx >= 0 && idx < (int)app.previewWorkbooks.size()) {
                refreshPreviewFromWorkbook(app, app.previewWorkbooks[idx].path);
            }
            return 0;
        }
        if (LOWORD(wp) == IDC_PREVIEW_SHEET && HIWORD(wp) == CBN_SELCHANGE) {
            app.activePreviewSheet = (int)SendMessageW(app.previewSheet, CB_GETCURSEL, 0, 0);
            app.reverseXmlDirty = true;
            populatePreviewList(app);
            return 0;
        }
        if (LOWORD(wp) == IDC_JSON_MONITOR) {
            int notify = HIWORD(wp);
            if (notify == CBN_SELCHANGE) {
                if (!app.jsonMonitorRefreshing &&
                    !SendMessageW(app.jsonMonitor, CB_GETDROPPEDSTATE, 0, 0)) {
                    int idx = (int)SendMessageW(app.jsonMonitor, CB_GETCURSEL, 0, 0);
                    selectJsonMonitorChoice(app, idx);
                }
                return 0;
            }
            if (notify == CBN_SELENDOK) {
                if (!app.jsonMonitorRefreshing) {
                    int idx = (int)SendMessageW(app.jsonMonitor, CB_GETCURSEL, 0, 0);
                    selectJsonMonitorChoice(app, idx);
                }
                return 0;
            }
            if (notify == CBN_CLOSEUP) {
                if (app.jsonMonitorRefreshPending) {
                    std::string selected = app.activeTraceDir.empty()
                                               ? app.pendingJsonMonitorTraceDir
                                               : app.activeTraceDir;
                    app.jsonMonitorRefreshPending = false;
                    app.pendingJsonMonitorTraceDir.clear();
                    refreshJsonMonitorChoices(app, selected);
                }
                return 0;
            }
            return 0;
        }
        if (LOWORD(wp) == IDC_BROWSE_JSON) {
            std::string path;
            if (openFileDialog(hwnd, L"\x6DFB\x52A0 jsondata \x6587\x4EF6", L"Text/JSON Files\0*.txt;*.json\0All Files\0*.*\0", path)) {
                std::vector<std::string> paths = splitPathList(getText(hwnd, IDC_JSON_PATH));
                if (std::find(paths.begin(), paths.end(), path) == paths.end()) paths.push_back(path);
                setText(hwnd, IDC_JSON_PATH, joinPaths(paths));
            }
            return 0;
        }
        switch (LOWORD(wp)) {
        case IDC_GET_LEDGER: runGetLedger(app); return 0;
        case IDC_INIT_MQ: runInitMq(app); return 0;
        case IDC_TRACE: runTrace(app); return 0;
        case IDC_PARSE: runParse(app); return 0;
        case IDC_IMPORT_ICD: runImportIcd(app); return 0;
        case IDC_REVERSE_XML: runReverseXml(app); return 0;
        case IDC_EXPORT_XML: runExportXml(app); return 0;
        case IDC_BROWSE_XML: {
            std::string path;
            if (openFileDialog(hwnd, L"选择 XML 文件", L"XML Files\0*.xml\0All Files\0*.*\0", path)) setText(hwnd, IDC_XML_PATH, path);
            return 0;
        }
        case IDC_BROWSE_JSON: {
            std::string path;
            if (openFileDialog(hwnd, L"选择 jsondata.txt", L"Text/JSON Files\0*.txt;*.json\0All Files\0*.*\0", path)) setText(hwnd, IDC_JSON_PATH, path);
            return 0;
        }
        case IDC_ADD_ORIGIN: {
            std::string path;
            if (openFileDialog(hwnd, L"选择 origin 文件", L"Text/JSON Files\0*.txt;*.json\0All Files\0*.*\0", path)) {
                std::string old = getText(hwnd, IDC_ORIGIN_PATHS);
                if (!old.empty() && old.back() != '\n' && old.back() != '\r') old += "\r\n";
                setText(hwnd, IDC_ORIGIN_PATHS, old + path);
            }
            return 0;
        }
        }
        break;
    case WM_NOTIFY:
        if (((LPNMHDR)lp)->idFrom == IDC_PREVIEW_LIST && ((LPNMHDR)lp)->code == NM_DBLCLK) {
            auto* item = reinterpret_cast<NMITEMACTIVATE*>(lp);
            if (item->iItem >= 0 && item->iSubItem >= 0) {
                PostMessageW(hwnd, WM_PQ_START_PREVIEW_EDIT,
                             static_cast<WPARAM>(item->iItem),
                             static_cast<LPARAM>(item->iSubItem));
            }
            return 0;
        }
        if (((LPNMHDR)lp)->idFrom == IDC_PREVIEW_LIST && ((LPNMHDR)lp)->code == NM_CUSTOMDRAW) {
            auto* cd = reinterpret_cast<NMLVCUSTOMDRAW*>(lp);
            if (cd->nmcd.dwDrawStage == CDDS_PREPAINT) return CDRF_NOTIFYITEMDRAW;
            if (cd->nmcd.dwDrawStage == CDDS_ITEMPREPAINT) return CDRF_NOTIFYSUBITEMDRAW;
            if (cd->nmcd.dwDrawStage == (CDDS_ITEMPREPAINT | CDDS_SUBITEM)) {
                size_t idx = static_cast<size_t>(cd->nmcd.lItemlParam);
                int status = 0;
                std::string cellStyle;
                if (!app.previewSheets.empty() &&
                    app.activePreviewSheet >= 0 &&
                    app.activePreviewSheet < (int)app.previewSheets.size() &&
                    idx < app.previewSheets[app.activePreviewSheet].rows.size()) {
                    const PreviewSheetRow& row = app.previewSheets[app.activePreviewSheet].rows[idx];
                    status = row.status;
                    if (cd->iSubItem >= 0 && cd->iSubItem < (int)row.cellStyles.size()) {
                        cellStyle = row.cellStyles[cd->iSubItem];
                    }
                }
                if (cellStyle == "OriginPickBlue") cd->clrTextBk = RGB(207, 226, 243);
                else if (status == 1) cd->clrTextBk = RGB(217, 234, 211);
                else if (status == 2) cd->clrTextBk = RGB(252, 228, 214);
                else if (status == 3) cd->clrTextBk = RGB(244, 204, 204);
                else if (status == 4) cd->clrTextBk = RGB(217, 234, 211);
                else if (status == 5) cd->clrTextBk = RGB(232, 238, 247);
                else if (status == 6) cd->clrTextBk = RGB(244, 244, 244);
                return CDRF_NEWFONT;
            }
        }
        if (((LPNMHDR)lp)->idFrom == IDC_TAB && ((LPNMHDR)lp)->code == TCN_SELCHANGE) {
            showPage(app, (int)SendMessageW(app.tab, TCM_GETCURSEL, 0, 0));
            return 0;
        }
        if (((LPNMHDR)lp)->idFrom == IDC_TREE && ((LPNMHDR)lp)->code == TVN_SELCHANGEDW) {
            auto* tv = (LPNMTREEVIEWW)lp;
            auto* ref = (NodeRef*)tv->itemNew.lParam;
            if (ref) {
                app.selectedDevice = ref->device;
                app.selectedMonitor = ref->monitor;
                updateDetails(app);
                updatePathsForSelection(app);
            }
            return 0;
        }
        if (((LPNMHDR)lp)->idFrom == IDC_JSON_TREE && ((LPNMHDR)lp)->code == TVN_SELCHANGEDW) {
            auto* tv = (LPNMTREEVIEWW)lp;
            auto* ref = (JsonNodeRef*)tv->itemNew.lParam;
            app.selectedJson = ref ? ref->index : -1;
            updateJsonDetail(app);
            return 0;
        }
        break;
    case WM_DESTROY:
        if (app.previewFont) DeleteObject(app.previewFont);
        if (app.xmlFont) DeleteObject(app.xmlFont);
        if (app.ownsFont && app.font) DeleteObject(app.font);
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProcW(hwnd, msg, wp, lp);
}

} // namespace

int runPqGuiApp() {
    AppState app;
    g_app = &app;
    app.inst = GetModuleHandleW(nullptr);
    CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED);

    INITCOMMONCONTROLSEX icc{};
    icc.dwSize = sizeof(icc);
    icc.dwICC = ICC_TREEVIEW_CLASSES | ICC_TAB_CLASSES | ICC_STANDARD_CLASSES | ICC_LISTVIEW_CLASSES;
    InitCommonControlsEx(&icc);

    WNDCLASSW wc{};
    wc.hInstance = app.inst;
    wc.lpszClassName = L"PqToolWindow";
    wc.lpfnWndProc = wndProc;
    wc.hCursor = LoadCursorW(nullptr, MAKEINTRESOURCEW(32512));
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    RegisterClassW(&wc);

    WNDCLASSW panel{};
    panel.hInstance = app.inst;
    panel.lpszClassName = L"PqToolPanel";
    panel.lpfnWndProc = panelProc;
    panel.hCursor = LoadCursorW(nullptr, MAKEINTRESOURCEW(32512));
    panel.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    RegisterClassW(&panel);

    HWND hwnd = CreateWindowExW(0, wc.lpszClassName, L"PQ 映射解析与追踪工具",
                                WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 1210, 820,
                                nullptr, nullptr, app.inst, nullptr);
    if (!hwnd) {
        CoUninitialize();
        return 1;
    }
    SetWindowTextW(hwnd, L"PQ \x6620\x5C04\x89E3\x6790\x4E0E\x8FFD\x8E2A\x5DE5\x5177");
    ShowWindow(hwnd, SW_SHOW);
    UpdateWindow(hwnd);

    MSG message;
    while (GetMessageW(&message, nullptr, 0, 0) > 0) {
        TranslateMessage(&message);
        DispatchMessageW(&message);
    }

    CoUninitialize();
    g_app = nullptr;
    return (int)message.wParam;
}