PrtEasySetup.cpp

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

#include <windows.h>
#include <commctrl.h>
#include <shellapi.h>
#include <winspool.h>
#include <winsvc.h>

#include <algorithm>
#include <cctype>
#include <cwchar>
#include <cwctype>
#include <filesystem>
#include <fstream>
#include <map>
#include <set>
#include <string>
#include <vector>

#ifdef _MSC_VER
#pragma comment(lib, "Advapi32.lib")
#pragma comment(lib, "Comctl32.lib")
#pragma comment(lib, "Gdi32.lib")
#pragma comment(lib, "Shell32.lib")
#pragma comment(lib, "User32.lib")
#pragma comment(lib, "Winspool.lib")
#endif

namespace fs = std::filesystem;

struct Config {
    std::wstring mode;
    std::wstring portValue;
    std::wstring printerName;
    std::wstring driverName;
    std::wstring infName;
    std::wstring flags;
};

struct TextInputDialogState {
    std::wstring title;
    std::wstring prompt;
    std::wstring value;
    HWND editHandle = nullptr;
    bool accepted = false;
};

struct SelectionDialogState {
    std::wstring title;
    std::wstring prompt;
    std::vector<std::wstring> options;
    HWND listHandle = nullptr;
    int selectedIndex = -1;
    bool accepted = false;
};

fs::path g_baseDir;
fs::path g_logPath;

enum class AppLanguage {
    English,
    TraditionalChinese
};

struct ProgressWindowState {
    HWND windowHandle = nullptr;
    HWND labelHandle = nullptr;
    HWND progressHandle = nullptr;
    bool visible = false;
};

AppLanguage g_appLanguage = AppLanguage::English;
std::wstring g_languageSetting = L"auto";
ProgressWindowState g_progressWindow;

constexpr int kDialogButtonWidth = 88;
constexpr int kDialogButtonHeight = 28;
constexpr int kTextInputWidth = 420;
constexpr int kTextInputHeight = 165;
constexpr int kSelectionWidth = 460;
constexpr int kSelectionHeight = 430;
constexpr int kProgressWidth = 440;
constexpr int kProgressHeight = 145;
constexpr int kAppIconResourceId = 1;

constexpr int kTextPromptId = 1001;
constexpr int kTextEditId = 1002;
constexpr int kListPromptId = 1101;
constexpr int kListBoxId = 1102;
constexpr int kProgressLabelId = 1201;
constexpr int kProgressBarId = 1202;

std::wstring BuildPrinterInfoMessage(const Config& config);
HFONT GetDialogFont();
void CenterWindowOnOwner(HWND handle, HWND owner, int width, int height);

const wchar_t* UiText(const wchar_t* english, const wchar_t* traditionalChinese) {
    return g_appLanguage == AppLanguage::TraditionalChinese ? traditionalChinese : english;
}

std::wstring Trim(const std::wstring& value) {
    const wchar_t* whitespace = L" \t\r\n";
    const auto start = value.find_first_not_of(whitespace);
    if (start == std::wstring::npos) {
        return L"";
    }
    const auto end = value.find_last_not_of(whitespace);
    return value.substr(start, end - start + 1);
}

std::wstring StripQuotes(std::wstring value) {
    value = Trim(value);
    if (value.size() >= 2 && value.front() == L'"' && value.back() == L'"') {
        return value.substr(1, value.size() - 2);
    }
    return value;
}

std::wstring ToLowerCopy(std::wstring value) {
    std::transform(value.begin(), value.end(), value.begin(), [](wchar_t ch) {
        return static_cast<wchar_t>(::towlower(ch));
    });
    return value;
}

bool IEquals(const std::wstring& left, const std::wstring& right) {
    return ToLowerCopy(left) == ToLowerCopy(right);
}

bool StartsWithI(const std::wstring& value, const std::wstring& prefix) {
    if (value.size() < prefix.size()) {
        return false;
    }
    return IEquals(value.substr(0, prefix.size()), prefix);
}

bool ContainsI(const std::wstring& value, const std::wstring& needle) {
    return ToLowerCopy(value).find(ToLowerCopy(needle)) != std::wstring::npos;
}

std::wstring NormalizeFlags(std::wstring flags) {
    flags = Trim(flags);
    if (flags.empty()) {
        flags = L"000";
    }
    while (flags.size() < 3) {
        flags.push_back(L'0');
    }
    return flags.substr(0, 3);
}

std::wstring WideFromBytes(const std::string& input, UINT codePage = CP_ACP) {
    if (input.empty()) {
        return L"";
    }
    const int size = MultiByteToWideChar(codePage, 0, input.data(), static_cast<int>(input.size()), nullptr, 0);
    if (size <= 0) {
        return L"";
    }
    std::wstring output(size, L'\0');
    MultiByteToWideChar(codePage, 0, input.data(), static_cast<int>(input.size()), output.data(), size);
    return output;
}

std::string BytesFromWide(const std::wstring& input, UINT codePage = CP_ACP) {
    if (input.empty()) {
        return "";
    }
    const int size = WideCharToMultiByte(codePage, 0, input.c_str(), static_cast<int>(input.size()), nullptr, 0, nullptr, nullptr);
    if (size <= 0) {
        return "";
    }
    std::string output(size, '\0');
    WideCharToMultiByte(codePage, 0, input.c_str(), static_cast<int>(input.size()), output.data(), size, nullptr, nullptr);
    return output;
}

std::wstring ReadTextFile(const fs::path& path) {
    std::ifstream input(path, std::ios::binary);
    if (!input) {
        return L"";
    }

    std::string bytes((std::istreambuf_iterator<char>(input)), std::istreambuf_iterator<char>());
    if (bytes.size() >= 3 &&
        static_cast<unsigned char>(bytes[0]) == 0xEF &&
        static_cast<unsigned char>(bytes[1]) == 0xBB &&
        static_cast<unsigned char>(bytes[2]) == 0xBF) {
        return WideFromBytes(bytes.substr(3), CP_UTF8);
    }

    if (bytes.size() >= 2) {
        const unsigned char b0 = static_cast<unsigned char>(bytes[0]);
        const unsigned char b1 = static_cast<unsigned char>(bytes[1]);
        if (b0 == 0xFF && b1 == 0xFE) {
            const wchar_t* data = reinterpret_cast<const wchar_t*>(bytes.data() + 2);
            return std::wstring(data, (bytes.size() - 2) / sizeof(wchar_t));
        }
    }

    return WideFromBytes(bytes, CP_ACP);
}

bool WriteTextFileAcp(const fs::path& path, const std::wstring& text) {
    std::ofstream output(path, std::ios::binary | std::ios::trunc);
    if (!output) {
        return false;
    }
    const std::string bytes = BytesFromWide(text, CP_ACP);
    output.write(bytes.data(), static_cast<std::streamsize>(bytes.size()));
    return static_cast<bool>(output);
}

std::vector<std::wstring> SplitLines(const std::wstring& text) {
    std::vector<std::wstring> lines;
    std::wstring current;
    for (wchar_t ch : text) {
        if (ch == L'\r') {
            continue;
        }
        if (ch == L'\n') {
            lines.push_back(current);
            current.clear();
        } else {
            current.push_back(ch);
        }
    }
    if (!current.empty()) {
        lines.push_back(current);
    }
    return lines;
}

std::vector<std::wstring> SplitCsvLine(const std::wstring& line) {
    std::vector<std::wstring> parts;
    std::wstring current;
    for (wchar_t ch : line) {
        if (ch == L',') {
            parts.push_back(current);
            current.clear();
        } else {
            current.push_back(ch);
        }
    }
    parts.push_back(current);
    return parts;
}

std::wstring QuoteArg(const std::wstring& argument) {
    if (argument.empty()) {
        return L"\"\"";
    }

    bool needsQuotes = false;
    for (wchar_t ch : argument) {
        if (iswspace(ch) || ch == L'"') {
            needsQuotes = true;
            break;
        }
    }

    if (!needsQuotes) {
        return argument;
    }

    std::wstring result = L"\"";
    unsigned int backslashes = 0;
    for (wchar_t ch : argument) {
        if (ch == L'\\') {
            ++backslashes;
            continue;
        }
        if (ch == L'"') {
            result.append(backslashes * 2 + 1, L'\\');
            result.push_back(L'"');
            backslashes = 0;
            continue;
        }
        result.append(backslashes, L'\\');
        backslashes = 0;
        result.push_back(ch);
    }
    result.append(backslashes * 2, L'\\');
    result.push_back(L'"');
    return result;
}

std::wstring BuildCommandLine(const std::wstring& executable, const std::vector<std::wstring>& args) {
    std::wstring commandLine = QuoteArg(executable);
    for (const auto& arg : args) {
        commandLine.push_back(L' ');
        commandLine += QuoteArg(arg);
    }
    return commandLine;
}

std::wstring GetTimestamp() {
    SYSTEMTIME st{};
    GetLocalTime(&st);
    wchar_t buffer[64] = {};
    swprintf_s(buffer, L"%04u-%02u-%02u %02u:%02u:%02u",
        st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
    return buffer;
}

void Log(const std::wstring& message) {
    std::wofstream output(g_logPath, std::ios::app);
    if (!output) {
        return;
    }
    output << L"[" << GetTimestamp() << L"] " << message << L"\n";
}

std::wstring FormatWin32Error(DWORD errorCode) {
    LPWSTR buffer = nullptr;
    const DWORD flags = FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS;
    const DWORD length = FormatMessageW(flags, nullptr, errorCode, 0, reinterpret_cast<LPWSTR>(&buffer), 0, nullptr);
    std::wstring message = length && buffer ? Trim(buffer) : L"Unknown error";
    if (buffer) {
        LocalFree(buffer);
    }
    wchar_t prefix[64] = {};
    swprintf_s(prefix, L"0x%08lX (%lu): ", errorCode, errorCode);
    return std::wstring(prefix) + message;
}

int ShowMessage(const std::wstring& title, const std::wstring& message, UINT flags) {
    return MessageBoxW(nullptr, message.c_str(), title.c_str(), flags | MB_TOPMOST);
}

void ShowErrorWithLog(const std::wstring& title, const std::wstring& message) {
    ShowMessage(title, message + L"\n\n" + UiText(L"Log file:", L"\u8A18\u9304\u6A94\uff1A") + L"\n" + g_logPath.wstring(), MB_OK | MB_ICONERROR);
}

bool CanRenderTraditionalChinese() {
    HDC dc = GetDC(nullptr);
    if (!dc) {
        return false;
    }

    const wchar_t* sample = L"\u5370\u8868\u6A5F\u8A2D\u5B9A";
    WORD glyphs[8] = {};
    HGDIOBJ oldFont = SelectObject(dc, GetDialogFont());
    const DWORD flags = GGI_MARK_NONEXISTING_GLYPHS;
    const DWORD count = GetGlyphIndicesW(dc, sample, static_cast<int>(wcslen(sample)), glyphs, flags);
    if (oldFont) {
        SelectObject(dc, oldFont);
    }
    ReleaseDC(nullptr, dc);

    if (count == GDI_ERROR) {
        return false;
    }

    for (std::size_t i = 0; i < wcslen(sample); ++i) {
        if (glyphs[i] == 0xFFFF) {
            return false;
        }
    }
    return true;
}

AppLanguage DetectSystemLanguage() {
    wchar_t localeName[LOCALE_NAME_MAX_LENGTH] = {};
    if (GetUserDefaultLocaleName(localeName, LOCALE_NAME_MAX_LENGTH) <= 0) {
        return AppLanguage::English;
    }

    const std::wstring locale = ToLowerCopy(localeName);
    if (locale.rfind(L"zh", 0) == 0 && CanRenderTraditionalChinese()) {
        return AppLanguage::TraditionalChinese;
    }

    return AppLanguage::English;
}

std::wstring ReadIniLanguageSetting(const fs::path& path) {
    const std::wstring text = ReadTextFile(path);
    if (text.empty()) {
        return L"auto";
    }

    for (const auto& rawLine : SplitLines(text)) {
        const std::wstring line = Trim(rawLine);
        if (line.empty() || StartsWithI(line, L"#") || StartsWithI(line, L";")) {
            continue;
        }

        const auto pos = line.find(L'=');
        if (pos == std::wstring::npos) {
            continue;
        }

        const std::wstring key = ToLowerCopy(Trim(line.substr(0, pos)));
        const std::wstring value = Trim(line.substr(pos + 1));
        if (key == L"lang" || key == L"language" || key == L"ui_lang") {
            return value.empty() ? L"auto" : value;
        }
    }

    return L"auto";
}

void ApplyLanguageSetting(const std::wstring& value) {
    g_languageSetting = ToLowerCopy(Trim(value));
    if (g_languageSetting.empty() || g_languageSetting == L"auto") {
        g_appLanguage = DetectSystemLanguage();
        return;
    }

    if (g_languageSetting == L"en" || g_languageSetting == L"en-us" || g_languageSetting == L"english") {
        g_appLanguage = AppLanguage::English;
        return;
    }

    if (g_languageSetting == L"zh" ||
        g_languageSetting == L"zh-tw" ||
        g_languageSetting == L"zh-hk" ||
        g_languageSetting == L"zh-mo" ||
        g_languageSetting == L"tw" ||
        g_languageSetting == L"cht" ||
        g_languageSetting == L"traditional") {
        g_appLanguage = CanRenderTraditionalChinese() ? AppLanguage::TraditionalChinese : AppLanguage::English;
        return;
    }

    g_appLanguage = DetectSystemLanguage();
}

HFONT GetDialogFont() {
    static HFONT font = reinterpret_cast<HFONT>(GetStockObject(DEFAULT_GUI_FONT));
    return font;
}

HICON GetAppIconLarge() {
    static HICON icon = reinterpret_cast<HICON>(
        LoadImageW(GetModuleHandleW(nullptr),
                   MAKEINTRESOURCEW(kAppIconResourceId),
                   IMAGE_ICON,
                   GetSystemMetrics(SM_CXICON),
                   GetSystemMetrics(SM_CYICON),
                   LR_DEFAULTCOLOR));
    return icon ? icon : LoadIconW(nullptr, IDI_APPLICATION);
}

HICON GetAppIconSmall() {
    static HICON icon = reinterpret_cast<HICON>(
        LoadImageW(GetModuleHandleW(nullptr),
                   MAKEINTRESOURCEW(kAppIconResourceId),
                   IMAGE_ICON,
                   GetSystemMetrics(SM_CXSMICON),
                   GetSystemMetrics(SM_CYSMICON),
                   LR_DEFAULTCOLOR));
    return icon ? icon : LoadIconW(nullptr, IDI_APPLICATION);
}

void SetControlFont(HWND handle) {
    if (handle) {
        SendMessageW(handle, WM_SETFONT, reinterpret_cast<WPARAM>(GetDialogFont()), TRUE);
    }
}

HMENU MenuId(int value) {
    return reinterpret_cast<HMENU>(static_cast<INT_PTR>(value));
}

int g_currentProgressPercent = 0;
int g_targetMaxPercent = 0;
std::wstring g_currentProgressMessage;
ULONGLONG g_lastStepTick = 0;

void PumpPendingMessages() {
    MSG msg{};
    while (PeekMessageW(&msg, nullptr, 0, 0, PM_REMOVE)) {
        TranslateMessage(&msg);
        DispatchMessageW(&msg);
    }

    if (g_progressWindow.visible && g_currentProgressPercent < g_targetMaxPercent) {
        ULONGLONG now = GetTickCount64();
        if (now - g_lastStepTick >= 1000) {
            g_currentProgressPercent++;
            g_lastStepTick = now;

            if (g_progressWindow.labelHandle) {
                std::wstring text = g_currentProgressMessage;
                text += L" (" + std::to_wstring(g_currentProgressPercent) + L"%)";
                SetWindowTextW(g_progressWindow.labelHandle, text.c_str());
            }
            if (g_progressWindow.progressHandle) {
                SendMessageW(g_progressWindow.progressHandle, PBM_SETPOS, g_currentProgressPercent, 0);
            }
        }
    }
}

bool WaitForHandleWithMessages(HANDLE handle, DWORD timeoutMs, DWORD& waitResult) {
    const DWORD startTick = GetTickCount();
    for (;;) {
        const DWORD elapsed = GetTickCount() - startTick;
        if (timeoutMs != INFINITE && elapsed >= timeoutMs) {
            waitResult = WAIT_TIMEOUT;
            return false;
        }

        DWORD remaining = INFINITE;
        if (timeoutMs != INFINITE) {
            remaining = timeoutMs - elapsed;
            if (remaining > 50) {
                remaining = 50;
            }
        }

        const DWORD result = MsgWaitForMultipleObjects(1, &handle, FALSE, remaining, QS_ALLINPUT);
        if (result == WAIT_OBJECT_0) {
            waitResult = WAIT_OBJECT_0;
            return true;
        }
        if (result == WAIT_TIMEOUT && timeoutMs != INFINITE) {
            continue;
        }
        if (result == WAIT_OBJECT_0 + 1) {
            PumpPendingMessages();
            continue;
        }

        waitResult = result;
        return false;
    }
}

void SleepWithMessages(DWORD milliseconds) {
    const DWORD startTick = GetTickCount();
    while ((GetTickCount() - startTick) < milliseconds) {
        PumpPendingMessages();
        Sleep(20);
    }
}

LRESULT CALLBACK ProgressWindowProc(HWND handle, UINT message, WPARAM wParam, LPARAM lParam) {
    switch (message) {
    case WM_CREATE: {
        HWND label = CreateWindowExW(
            0, L"STATIC", L"",
            WS_CHILD | WS_VISIBLE,
            14, 16, kProgressWidth - 28, 32,
            handle, MenuId(kProgressLabelId), nullptr, nullptr);
        SetControlFont(label);
        g_progressWindow.labelHandle = label;

        HWND progress = CreateWindowExW(
            0, PROGRESS_CLASSW, L"",
            WS_CHILD | WS_VISIBLE | PBS_SMOOTH,
            14, 58, kProgressWidth - 28, 20,
            handle, MenuId(kProgressBarId), nullptr, nullptr);
        g_progressWindow.progressHandle = progress;
        SendMessageW(progress, PBM_SETRANGE, 0, MAKELPARAM(0, 100));
        SendMessageW(progress, PBM_SETPOS, 0, 0);
        return 0;
    }
    case WM_CTLCOLORSTATIC: {
        HDC hdc = reinterpret_cast<HDC>(wParam);
        SetBkMode(hdc, TRANSPARENT);
        return reinterpret_cast<LRESULT>(GetSysColorBrush(COLOR_BTNFACE));
    }
    case WM_CLOSE:
        return 0;
    default:
        break;
    }
    return DefWindowProcW(handle, message, wParam, lParam);
}

void ShowProgressWindow(const std::wstring& title, const std::wstring& message) {
    if (!g_progressWindow.windowHandle) {
        INITCOMMONCONTROLSEX icc{};
        icc.dwSize = sizeof(icc);
        icc.dwICC = ICC_PROGRESS_CLASS;
        InitCommonControlsEx(&icc);

        static HINSTANCE instance = GetModuleHandleW(nullptr);
        WNDCLASSEXW windowClass{};
        windowClass.cbSize = sizeof(windowClass);
        windowClass.lpfnWndProc = ProgressWindowProc;
        windowClass.hInstance = instance;
        windowClass.hIcon = GetAppIconLarge();
        windowClass.hIconSm = GetAppIconSmall();
        windowClass.hCursor = LoadCursorW(nullptr, IDC_ARROW);
        windowClass.hbrBackground = GetSysColorBrush(COLOR_BTNFACE);
        windowClass.lpszClassName = L"PrtEasySetupProgressWindow";
        RegisterClassExW(&windowClass);

        HWND owner = GetActiveWindow();
        g_progressWindow.windowHandle = CreateWindowExW(
            WS_EX_DLGMODALFRAME,
            L"PrtEasySetupProgressWindow",
            title.c_str(),
            WS_POPUP | WS_CAPTION,
            CW_USEDEFAULT, CW_USEDEFAULT, kProgressWidth, kProgressHeight,
            owner, nullptr, instance, nullptr);

        if (!g_progressWindow.windowHandle) {
            return;
        }

        CenterWindowOnOwner(g_progressWindow.windowHandle, owner, kProgressWidth, kProgressHeight);
        ShowWindow(g_progressWindow.windowHandle, SW_SHOW);
        UpdateWindow(g_progressWindow.windowHandle);
    }

    if (g_progressWindow.windowHandle) {
        SetWindowTextW(g_progressWindow.windowHandle, title.c_str());
    }
    if (g_progressWindow.labelHandle) {
        SetWindowTextW(g_progressWindow.labelHandle, message.c_str());
    }
    g_progressWindow.visible = true;
    PumpPendingMessages();
}

void UpdateProgressWindow(const std::wstring& message, int percent = -1) {
    if (percent >= 0) {
        g_currentProgressPercent = percent;
        g_lastStepTick = GetTickCount64();
        
        // 根據主要等待步驟設定平滑推進上限，防止卡在 30% 一動不動
        if (percent == 10) g_targetMaxPercent = 29;      // 準備連接埠：10% -> 29%
        else if (percent == 30) g_targetMaxPercent = 69; // 匯入驅動：30% -> 69%
        else if (percent == 70) g_targetMaxPercent = 84; // 建立佇列：70% -> 84%
        else g_targetMaxPercent = percent;
    }
    g_currentProgressMessage = message;

    if (g_progressWindow.labelHandle) {
        std::wstring text = message;
        if (g_currentProgressPercent >= 0 && g_currentProgressPercent <= 100) {
            text += L" (" + std::to_wstring(g_currentProgressPercent) + L"%)";
        }
        SetWindowTextW(g_progressWindow.labelHandle, text.c_str());
    }
    if (g_progressWindow.progressHandle && g_currentProgressPercent >= 0 && g_currentProgressPercent <= 100) {
        SendMessageW(g_progressWindow.progressHandle, PBM_SETPOS, g_currentProgressPercent, 0);
    }
    PumpPendingMessages();
}

void CloseProgressWindow() {
    if (g_progressWindow.windowHandle) {
        DestroyWindow(g_progressWindow.windowHandle);
    }
    g_progressWindow.windowHandle = nullptr;
    g_progressWindow.labelHandle = nullptr;
    g_progressWindow.progressHandle = nullptr;
    g_progressWindow.visible = false;
    PumpPendingMessages();
}

void CenterWindowOnOwner(HWND handle, HWND owner, int width, int height) {
    RECT target{};
    if (owner && GetWindowRect(owner, &target)) {
        const int x = target.left + ((target.right - target.left) - width) / 2;
        const int y = target.top + ((target.bottom - target.top) - height) / 2;
        SetWindowPos(handle, nullptr, x, y, width, height, SWP_NOZORDER | SWP_NOACTIVATE);
        return;
    }

    RECT workArea{};
    SystemParametersInfoW(SPI_GETWORKAREA, 0, &workArea, 0);
    const int x = workArea.left + ((workArea.right - workArea.left) - width) / 2;
    const int y = workArea.top + ((workArea.bottom - workArea.top) - height) / 2;
    SetWindowPos(handle, nullptr, x, y, width, height, SWP_NOZORDER | SWP_NOACTIVATE);
}

std::wstring GetWindowTextString(HWND handle) {
    const int length = GetWindowTextLengthW(handle);
    std::wstring value(static_cast<std::size_t>(length) + 1, L'\0');
    GetWindowTextW(handle, value.data(), length + 1);
    value.resize(static_cast<std::size_t>(length));
    return value;
}

LRESULT CALLBACK TextInputDialogProc(HWND handle, UINT message, WPARAM wParam, LPARAM lParam) {
    TextInputDialogState* state = reinterpret_cast<TextInputDialogState*>(GetWindowLongPtrW(handle, GWLP_USERDATA));

    switch (message) {
    case WM_NCCREATE: {
        auto* create = reinterpret_cast<CREATESTRUCTW*>(lParam);
        SetWindowLongPtrW(handle, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(create->lpCreateParams));
        return TRUE;
    }
    case WM_CREATE: {
        state = reinterpret_cast<TextInputDialogState*>(GetWindowLongPtrW(handle, GWLP_USERDATA));
        if (!state) {
            return -1;
        }

        HWND prompt = CreateWindowExW(
            0, L"STATIC", state->prompt.c_str(),
            WS_CHILD | WS_VISIBLE,
            14, 14, kTextInputWidth - 28, 42,
            handle, MenuId(kTextPromptId), nullptr, nullptr);
        SetControlFont(prompt);

        state->editHandle = CreateWindowExW(
            WS_EX_CLIENTEDGE, L"EDIT", state->value.c_str(),
            WS_CHILD | WS_VISIBLE | WS_TABSTOP | ES_AUTOHSCROLL,
            14, 62, kTextInputWidth - 28, 24,
            handle, MenuId(kTextEditId), nullptr, nullptr);
        SetControlFont(state->editHandle);

        HWND okButton = CreateWindowExW(
            0, L"BUTTON", UiText(L"OK", L"\u78BA\u5B9A"),
            WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_DEFPUSHBUTTON,
            kTextInputWidth - 190, 102, kDialogButtonWidth, kDialogButtonHeight,
            handle, MenuId(IDOK), nullptr, nullptr);
        SetControlFont(okButton);

        HWND cancelButton = CreateWindowExW(
            0, L"BUTTON", UiText(L"Cancel", L"\u53D6\u6D88"),
            WS_CHILD | WS_VISIBLE | WS_TABSTOP,
            kTextInputWidth - 96, 102, kDialogButtonWidth, kDialogButtonHeight,
            handle, MenuId(IDCANCEL), nullptr, nullptr);
        SetControlFont(cancelButton);

        SetFocus(state->editHandle);
        SendMessageW(state->editHandle, EM_SETSEL, 0, -1);
        return 0;
    }
    case WM_COMMAND:
        if (!state) {
            break;
        }

        switch (LOWORD(wParam)) {
        case IDOK:
            state->value = Trim(GetWindowTextString(state->editHandle));
            state->accepted = true;
            DestroyWindow(handle);
            return 0;
        case IDCANCEL:
            state->accepted = false;
            DestroyWindow(handle);
            return 0;
        default:
            break;
        }
        break;
    case WM_CTLCOLORSTATIC: {
        HDC hdc = reinterpret_cast<HDC>(wParam);
        SetBkMode(hdc, TRANSPARENT);
        return reinterpret_cast<LRESULT>(GetSysColorBrush(COLOR_BTNFACE));
    }
    case WM_CLOSE:
        if (state) {
            state->accepted = false;
        }
        DestroyWindow(handle);
        return 0;
    default:
        break;
    }

    return DefWindowProcW(handle, message, wParam, lParam);
}

LRESULT CALLBACK SelectionDialogProc(HWND handle, UINT message, WPARAM wParam, LPARAM lParam) {
    SelectionDialogState* state = reinterpret_cast<SelectionDialogState*>(GetWindowLongPtrW(handle, GWLP_USERDATA));

    switch (message) {
    case WM_NCCREATE: {
        auto* create = reinterpret_cast<CREATESTRUCTW*>(lParam);
        SetWindowLongPtrW(handle, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(create->lpCreateParams));
        return TRUE;
    }
    case WM_CREATE: {
        state = reinterpret_cast<SelectionDialogState*>(GetWindowLongPtrW(handle, GWLP_USERDATA));
        if (!state) {
            return -1;
        }

        HWND prompt = CreateWindowExW(
            0, L"STATIC", state->prompt.c_str(),
            WS_CHILD | WS_VISIBLE,
            14, 14, kSelectionWidth - 28, 36,
            handle, MenuId(kListPromptId), nullptr, nullptr);
        SetControlFont(prompt);

        state->listHandle = CreateWindowExW(
            WS_EX_CLIENTEDGE, L"LISTBOX", L"",
            WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_VSCROLL | LBS_NOTIFY,
            14, 52, kSelectionWidth - 28, 292,
            handle, MenuId(kListBoxId), nullptr, nullptr);
        SetControlFont(state->listHandle);

        for (const auto& option : state->options) {
            SendMessageW(state->listHandle, LB_ADDSTRING, 0, reinterpret_cast<LPARAM>(option.c_str()));
        }
        if (!state->options.empty()) {
            SendMessageW(state->listHandle, LB_SETCURSEL, 0, 0);
        }

        HWND okButton = CreateWindowExW(
            0, L"BUTTON", UiText(L"OK", L"\u78BA\u5B9A"),
            WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_DEFPUSHBUTTON,
            kSelectionWidth - 190, 358, kDialogButtonWidth, kDialogButtonHeight,
            handle, MenuId(IDOK), nullptr, nullptr);
        SetControlFont(okButton);

        HWND cancelButton = CreateWindowExW(
            0, L"BUTTON", UiText(L"Cancel", L"\u53D6\u6D88"),
            WS_CHILD | WS_VISIBLE | WS_TABSTOP,
            kSelectionWidth - 96, 358, kDialogButtonWidth, kDialogButtonHeight,
            handle, MenuId(IDCANCEL), nullptr, nullptr);
        SetControlFont(cancelButton);

        SetFocus(state->listHandle);
        return 0;
    }
    case WM_COMMAND:
        if (!state) {
            break;
        }

        if (LOWORD(wParam) == kListBoxId && HIWORD(wParam) == LBN_DBLCLK) {
            SendMessageW(handle, WM_COMMAND, MAKEWPARAM(IDOK, BN_CLICKED), 0);
            return 0;
        }

        switch (LOWORD(wParam)) {
        case IDOK: {
            const int selected = static_cast<int>(SendMessageW(state->listHandle, LB_GETCURSEL, 0, 0));
            if (selected == LB_ERR) {
                MessageBoxW(handle, UiText(L"Please select an item first.", L"\u8ACB\u5148\u9078\u64C7\u4E00\u500B\u9805\u76EE\u3002"), state->title.c_str(), MB_OK | MB_ICONINFORMATION | MB_TOPMOST);
                return 0;
            }
            state->selectedIndex = selected;
            state->accepted = true;
            DestroyWindow(handle);
            return 0;
        }
        case IDCANCEL:
            state->accepted = false;
            DestroyWindow(handle);
            return 0;
        default:
            break;
        }
        break;
    case WM_CTLCOLORSTATIC: {
        HDC hdc = reinterpret_cast<HDC>(wParam);
        SetBkMode(hdc, TRANSPARENT);
        return reinterpret_cast<LRESULT>(GetSysColorBrush(COLOR_BTNFACE));
    }
    case WM_CLOSE:
        if (state) {
            state->accepted = false;
        }
        DestroyWindow(handle);
        return 0;
    default:
        break;
    }

    return DefWindowProcW(handle, message, wParam, lParam);
}

template <typename TState>
bool RunModalWindow(const wchar_t* className,
                    WNDPROC procedure,
                    TState& state,
                    int width,
                    int height,
                    HWND* createdHandle = nullptr) {
    static HINSTANCE instance = GetModuleHandleW(nullptr);

    WNDCLASSEXW windowClass{};
    windowClass.cbSize = sizeof(windowClass);
    windowClass.lpfnWndProc = procedure;
    windowClass.hInstance = instance;
    windowClass.hIcon = GetAppIconLarge();
    windowClass.hIconSm = GetAppIconSmall();
    windowClass.hCursor = LoadCursorW(nullptr, IDC_ARROW);
    windowClass.hbrBackground = GetSysColorBrush(COLOR_BTNFACE);
    windowClass.lpszClassName = className;
    RegisterClassExW(&windowClass);

    HWND owner = GetActiveWindow();
    HWND handle = CreateWindowExW(
        WS_EX_DLGMODALFRAME | WS_EX_CONTROLPARENT,
        className,
        state.title.c_str(),
        WS_POPUP | WS_CAPTION | WS_SYSMENU,
        CW_USEDEFAULT, CW_USEDEFAULT, width, height,
        owner, nullptr, instance, &state);

    if (!handle) {
        return false;
    }

    if (createdHandle) {
        *createdHandle = handle;
    }

    CenterWindowOnOwner(handle, owner, width, height);
    if (owner) {
        EnableWindow(owner, FALSE);
    }

    ShowWindow(handle, SW_SHOW);
    UpdateWindow(handle);

    MSG msg{};
    while (IsWindow(handle) && GetMessageW(&msg, nullptr, 0, 0) > 0) {
        if (!IsDialogMessageW(handle, &msg)) {
            TranslateMessage(&msg);
            DispatchMessageW(&msg);
        }
    }

    if (owner) {
        EnableWindow(owner, TRUE);
        SetActiveWindow(owner);
    }

    return state.accepted;
}

bool ShowTextInputDialog(const std::wstring& title,
                         const std::wstring& prompt,
                         const std::wstring& defaultValue,
                         std::wstring& value) {
    TextInputDialogState state;
    state.title = title;
    state.prompt = prompt;
    state.value = defaultValue;

    if (!RunModalWindow(L"PrtEasySetupTextInputDialog", TextInputDialogProc, state, kTextInputWidth, kTextInputHeight)) {
        return false;
    }

    value = state.value;
    return true;
}

bool ShowSelectionDialog(const std::wstring& title,
                         const std::wstring& prompt,
                         const std::vector<std::wstring>& options,
                         std::wstring& value) {
    if (options.empty()) {
        return false;
    }

    SelectionDialogState state;
    state.title = title;
    state.prompt = prompt;
    state.options = options;

    if (!RunModalWindow(L"PrtEasySetupSelectionDialog", SelectionDialogProc, state, kSelectionWidth, kSelectionHeight)) {
        return false;
    }

    if (state.selectedIndex < 0 || state.selectedIndex >= static_cast<int>(state.options.size())) {
        return false;
    }

    value = state.options[static_cast<std::size_t>(state.selectedIndex)];
    return true;
}

bool RunProcess(const std::wstring& executable, const std::vector<std::wstring>& args, DWORD& exitCode, DWORD timeoutMs = 120000) {
    std::wstring commandLine = BuildCommandLine(executable, args);
    std::vector<wchar_t> mutableCommandLine(commandLine.begin(), commandLine.end());
    mutableCommandLine.push_back(L'\0');

    STARTUPINFOW si{};
    si.cb = sizeof(si);
    si.dwFlags = STARTF_USESHOWWINDOW;
    si.wShowWindow = SW_HIDE;

    PROCESS_INFORMATION pi{};
    Log(L"Run: " + commandLine);

    const BOOL created = CreateProcessW(
        nullptr,
        mutableCommandLine.data(),
        nullptr,
        nullptr,
        FALSE,
        CREATE_NO_WINDOW,
        nullptr,
        g_baseDir.c_str(),
        &si,
        &pi);

    if (!created) {
        exitCode = GetLastError();
        Log(L"CreateProcess failed: " + FormatWin32Error(exitCode));
        return false;
    }

    DWORD waitResult = WAIT_OBJECT_0;
    if (!WaitForHandleWithMessages(pi.hProcess, timeoutMs, waitResult) || waitResult == WAIT_TIMEOUT) {
        TerminateProcess(pi.hProcess, WAIT_TIMEOUT);
        exitCode = WAIT_TIMEOUT;
        Log(L"Process timeout; terminated.");
        CloseHandle(pi.hThread);
        CloseHandle(pi.hProcess);
        return false;
    }

    if (!GetExitCodeProcess(pi.hProcess, &exitCode)) {
        exitCode = GetLastError();
        Log(L"GetExitCodeProcess failed: " + FormatWin32Error(exitCode));
        CloseHandle(pi.hThread);
        CloseHandle(pi.hProcess);
        return false;
    }

    CloseHandle(pi.hThread);
    CloseHandle(pi.hProcess);
    Log(L"ExitCode: " + std::to_wstring(exitCode));
    return true;
}

bool IsRunningAsAdmin() {
    BOOL isMember = FALSE;
    SID_IDENTIFIER_AUTHORITY authority = SECURITY_NT_AUTHORITY;
    PSID adminGroup = nullptr;
    if (!AllocateAndInitializeSid(
        &authority, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS,
        0, 0, 0, 0, 0, 0, &adminGroup)) {
        return false;
    }
    CheckTokenMembership(nullptr, adminGroup, &isMember);
    FreeSid(adminGroup);
    return isMember == TRUE;
}

std::wstring JoinCurrentArgumentsWithoutExecutable() {
    int argc = 0;
    LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc);
    if (!argv || argc <= 1) {
        if (argv) {
            LocalFree(argv);
        }
        return L"";
    }

    std::wstring params;
    for (int i = 1; i < argc; ++i) {
        if (!params.empty()) {
            params.push_back(L' ');
        }
        params += QuoteArg(argv[i]);
    }
    LocalFree(argv);
    return params;
}

bool RelaunchAsAdmin() {
    wchar_t modulePath[MAX_PATH] = {};
    if (!GetModuleFileNameW(nullptr, modulePath, MAX_PATH)) {
        return false;
    }

    const std::wstring params = JoinCurrentArgumentsWithoutExecutable();
    HINSTANCE instance = ShellExecuteW(
        nullptr,
        L"runas",
        modulePath,
        params.empty() ? nullptr : params.c_str(),
        g_baseDir.c_str(),
        SW_SHOWNORMAL);

    return reinterpret_cast<INT_PTR>(instance) > 32;
}

std::wstring GetArchitectureLabel() {
    SYSTEM_INFO info{};
    GetNativeSystemInfo(&info);
    switch (info.wProcessorArchitecture) {
    case PROCESSOR_ARCHITECTURE_AMD64:
        return L"x64";
    case PROCESSOR_ARCHITECTURE_INTEL:
        return L"x86";
    case PROCESSOR_ARCHITECTURE_ARM64:
        return L"ARM64";
    default:
        return L"Unknown";
    }
}

bool IsPathCompatibleWithCurrentArchitecture(const fs::path& path) {
    const std::wstring lowered = ToLowerCopy(path.wstring());
    const std::wstring arch = ToLowerCopy(GetArchitectureLabel());
    if (arch == L"x64") {
        return lowered.find(L"\\arm64\\") == std::wstring::npos;
    }
    if (arch == L"x86") {
        return lowered.find(L"\\arm64\\") == std::wstring::npos &&
               lowered.find(L"\\amd64\\") == std::wstring::npos &&
               lowered.find(L"\\x64\\") == std::wstring::npos;
    }
    if (arch == L"arm64") {
        return lowered.find(L"\\amd64\\") == std::wstring::npos &&
               lowered.find(L"\\x64\\") == std::wstring::npos;
    }
    return true;
}

bool EnsureSpoolerRunning() {
    SC_HANDLE scm = OpenSCManagerW(nullptr, nullptr, SC_MANAGER_CONNECT);
    if (!scm) {
        Log(L"OpenSCManager failed: " + FormatWin32Error(GetLastError()));
        return false;
    }

    SC_HANDLE service = OpenServiceW(scm, L"Spooler", SERVICE_QUERY_STATUS | SERVICE_START);
    if (!service) {
        Log(L"OpenService(Spooler) failed: " + FormatWin32Error(GetLastError()));
        CloseServiceHandle(scm);
        return false;
    }

    SERVICE_STATUS_PROCESS status{};
    DWORD bytesNeeded = 0;
    if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, reinterpret_cast<LPBYTE>(&status), sizeof(status), &bytesNeeded)) {
        Log(L"QueryServiceStatusEx failed: " + FormatWin32Error(GetLastError()));
        CloseServiceHandle(service);
        CloseServiceHandle(scm);
        return false;
    }

    if (status.dwCurrentState == SERVICE_RUNNING) {
        CloseServiceHandle(service);
        CloseServiceHandle(scm);
        return true;
    }

    if (status.dwCurrentState == SERVICE_STOPPED) {
        if (!StartServiceW(service, 0, nullptr)) {
            Log(L"StartService failed: " + FormatWin32Error(GetLastError()));
            CloseServiceHandle(service);
            CloseServiceHandle(scm);
            return false;
        }
    }

    for (int i = 0; i < 30; ++i) {
        SleepWithMessages(1000);
        if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, reinterpret_cast<LPBYTE>(&status), sizeof(status), &bytesNeeded)) {
            break;
        }
        if (status.dwCurrentState == SERVICE_RUNNING) {
            CloseServiceHandle(service);
            CloseServiceHandle(scm);
            return true;
        }
    }

    CloseServiceHandle(service);
    CloseServiceHandle(scm);
    Log(L"Spooler did not reach running state.");
    return false;
}

bool ReadConfig(Config& config) {
    const std::wstring text = ReadTextFile(g_baseDir / L"ip.ini");
    if (text.empty()) {
        return false;
    }

    for (const auto& rawLine : SplitLines(text)) {
        const std::wstring line = Trim(rawLine);
        if (line.empty() || StartsWithI(line, L"#") || StartsWithI(line, L";")) {
            continue;
        }

        if (line.find(L'=') != std::wstring::npos && line.find(L',') == std::wstring::npos) {
            continue;
        }

        const auto parts = SplitCsvLine(line);
        if (parts.size() < 6) {
            continue;
        }

        config.mode = Trim(parts[0]);
        config.portValue = Trim(parts[1]);
        config.printerName = Trim(parts[2]);
        config.driverName = Trim(parts[3]);
        config.infName = Trim(parts[4]);
        config.flags = NormalizeFlags(parts[5]);
        return !config.portValue.empty() && !config.printerName.empty() && !config.driverName.empty() && !config.infName.empty();
    }

    return false;
}

std::vector<fs::path> FindInfFiles() {
    std::vector<fs::path> infFiles;
    std::error_code ec;
    if (!fs::exists(g_baseDir, ec)) {
        return infFiles;
    }

    for (const auto& entry : fs::recursive_directory_iterator(g_baseDir, ec)) {
        if (ec) {
            break;
        }
        if (!entry.is_regular_file()) {
            continue;
        }
        if (!IEquals(entry.path().extension().wstring(), L".inf")) {
            continue;
        }
        if (!IsPathCompatibleWithCurrentArchitecture(entry.path())) {
            continue;
        }
        infFiles.push_back(entry.path());
    }

    std::sort(infFiles.begin(), infFiles.end());
    return infFiles;
}

bool IsLikelyPrinterInf(const fs::path& infPath) {
    const std::wstring text = ReadTextFile(infPath);
    if (text.empty()) {
        return false;
    }

    if (ContainsI(text, L"class") && ContainsI(text, L"printer")) {
        return true;
    }

    const std::wstring fileName = ToLowerCopy(infPath.filename().wstring());
    return ContainsI(text, L"[manufacturer]") &&
        fileName.find(L"stub") == std::wstring::npos &&
        fileName.find(L"scan") == std::wstring::npos &&
        fileName.find(L"ipp") == std::wstring::npos &&
        fileName.find(L"wpd") == std::wstring::npos;
}

std::vector<std::wstring> ParseInfModels(const fs::path& infPath) {
    const auto lines = SplitLines(ReadTextFile(infPath));
    std::map<std::wstring, std::wstring> strings;
    std::vector<std::wstring> targetSections;
    std::vector<std::wstring> models;

    bool inStrings = false;
    for (const auto& rawLine : lines) {
        const std::wstring line = Trim(rawLine);
        if (line.empty() || StartsWithI(line, L";")) {
            continue;
        }
        if (!line.empty() && line.front() == L'[') {
            inStrings = StartsWithI(line, L"[Strings");
            if (!inStrings) {
                continue;
            }
        }
        if (!inStrings) {
            continue;
        }

        const auto pos = line.find(L'=');
        if (pos == std::wstring::npos) {
            continue;
        }

        const std::wstring key = ToLowerCopy(StripQuotes(line.substr(0, pos)));
        const std::wstring value = StripQuotes(line.substr(pos + 1));
        if (!Trim(key).empty()) {
            strings[key] = Trim(value);
        }
    }

    bool inManufacturer = false;
    for (const auto& rawLine : lines) {
        const std::wstring line = Trim(rawLine);
        if (line.empty() || StartsWithI(line, L";")) {
            continue;
        }

        if (!line.empty() && line.front() == L'[') {
            if (StartsWithI(line, L"[Manufacturer]")) {
                inManufacturer = true;
                continue;
            }
            if (inManufacturer) {
                break;
            }
        }

        if (!inManufacturer) {
            continue;
        }

        const auto pos = line.find(L'=');
        if (pos == std::wstring::npos) {
            continue;
        }

        std::wstring value = Trim(line.substr(pos + 1));
        const auto comma = value.find(L',');
        if (comma != std::wstring::npos) {
            value = value.substr(0, comma);
        }

        value = StripQuotes(value);
        if (value.size() > 2 && value.front() == L'%' && value.back() == L'%') {
            const auto found = strings.find(ToLowerCopy(value.substr(1, value.size() - 2)));
            if (found != strings.end()) {
                value = found->second;
            }
        }

        if (!value.empty()) {
            targetSections.push_back(value);
        }
    }

    bool inTargetSection = false;
    for (const auto& rawLine : lines) {
        const std::wstring line = Trim(rawLine);
        if (line.empty() || StartsWithI(line, L";")) {
            continue;
        }

        if (!line.empty() && line.front() == L'[' && line.back() == L']') {
            const std::wstring sectionName = Trim(line.substr(1, line.size() - 2));
            inTargetSection = false;
            for (const auto& target : targetSections) {
                if (IEquals(sectionName, target) || StartsWithI(sectionName, target + L".")) {
                    inTargetSection = true;
                    break;
                }
            }
            continue;
        }

        if (!inTargetSection) {
            continue;
        }

        const auto pos = line.find(L'=');
        if (pos == std::wstring::npos) {
            continue;
        }

        std::wstring model = Trim(line.substr(0, pos));
        const std::wstring lowered = ToLowerCopy(model);
        if (lowered.find(L"copyfiles") != std::wstring::npos ||
            lowered.find(L"include") != std::wstring::npos ||
            lowered.find(L"needs") != std::wstring::npos ||
            lowered.find(L"addreg") != std::wstring::npos ||
            lowered.find(L"delreg") != std::wstring::npos ||
            lowered.find(L"driverver") != std::wstring::npos) {
            continue;
        }

        model = StripQuotes(model);
        if (model.size() > 2 && model.front() == L'%' && model.back() == L'%') {
            const auto found = strings.find(ToLowerCopy(model.substr(1, model.size() - 2)));
            if (found != strings.end()) {
                model = StripQuotes(found->second);
            }
        }

        if (model.size() <= 3) {
            continue;
        }
        if (ContainsI(model, L"utility") ||
            ContainsI(model, L"monitor") ||
            ContainsI(model, L"port") ||
            ContainsI(model, L"storage") ||
            ContainsI(model, L"mass") ||
            ContainsI(model, L"disk")) {
            continue;
        }

        models.push_back(model);
    }

    std::set<std::wstring> seen;
    std::vector<std::wstring> uniqueModels;
    for (const auto& model : models) {
        const std::wstring key = ToLowerCopy(model);
        if (seen.insert(key).second) {
            uniqueModels.push_back(model);
        }
    }
    return uniqueModels;
}

void WriteSampleConfigIfMissing() {
    const fs::path samplePath = g_baseDir / L"ip.ini.sample";
    if (fs::exists(samplePath)) {
        return;
    }

    std::wstring driver = L"Printer Name";
    std::wstring inf = L"driver.inf";
    for (const auto& infPath : FindInfFiles()) {
        if (!IsLikelyPrinterInf(infPath)) {
            continue;
        }
        const auto models = ParseInfModels(infPath);
        if (!models.empty()) {
            driver = models.front();
            inf = infPath.filename().wstring();
            break;
        }
    }

    const std::wstring sample =
        L"ip,192.168.1.100," + driver + L"," + driver + L"," + inf + L",100\r\n"
        L"lang=auto\r\n";
    WriteTextFileAcp(samplePath, sample);
}

std::vector<std::wstring> GetUsbPortNames() {
    std::vector<std::wstring> ports;
    DWORD needed = 0;
    DWORD returned = 0;
    EnumPortsW(nullptr, 1, nullptr, 0, &needed, &returned);
    if (needed == 0) {
        return ports;
    }

    std::vector<BYTE> buffer(needed);
    if (!EnumPortsW(nullptr, 1, buffer.data(), needed, &needed, &returned)) {
        return ports;
    }

    const auto* portInfo = reinterpret_cast<PORT_INFO_1W*>(buffer.data());
    for (DWORD i = 0; i < returned; ++i) {
        if (portInfo[i].pName && StartsWithI(portInfo[i].pName, L"USB")) {
            ports.emplace_back(portInfo[i].pName);
        }
    }

    std::sort(ports.begin(), ports.end());
    ports.erase(std::unique(ports.begin(), ports.end()), ports.end());
    return ports;
}

std::vector<std::pair<std::wstring, fs::path>> BuildPrinterModelCandidates() {
    std::vector<std::pair<std::wstring, fs::path>> candidates;
    std::set<std::wstring> seen;

    for (const auto& infPath : FindInfFiles()) {
        if (!IsLikelyPrinterInf(infPath)) {
            continue;
        }

        const auto models = ParseInfModels(infPath);
        for (const auto& model : models) {
            const std::wstring key = ToLowerCopy(model);
            if (seen.insert(key).second) {
                candidates.emplace_back(model, infPath);
            }
        }
    }

    std::sort(candidates.begin(), candidates.end(), [](const auto& left, const auto& right) {
        return ToLowerCopy(left.first) < ToLowerCopy(right.first);
    });
    return candidates;
}

std::vector<std::pair<std::wstring, fs::path>> FilterModelCandidatesForDisplay(
    const std::vector<std::pair<std::wstring, fs::path>>& rawCandidates) {
    std::vector<std::pair<std::wstring, fs::path>> filtered;

    for (const auto& current : rawCandidates) {
        bool isNoise = false;
        const std::wstring currentLower = ToLowerCopy(current.first);

        for (const auto& other : rawCandidates) {
            if (&current == &other) {
                continue;
            }

            const std::wstring otherLower = ToLowerCopy(other.first);
            if (otherLower.find(currentLower) != std::wstring::npos &&
                otherLower != currentLower &&
                current.first.size() < 12) {
                isNoise = true;
                break;
            }
        }

        if (!isNoise) {
            filtered.push_back(current);
        }
    }

    return filtered;
}

bool BuildConfigInteractively(Config& config, bool& installNow) {
    installNow = false;
    WriteSampleConfigIfMissing();

    Config dummy;
    const bool hasValidConfig = ReadConfig(dummy);

    if (hasValidConfig) {
        if (ShowMessage(
                UiText(L"Recreate Config", L"\u91CD\u65B0\u5EFA\u7ACB\u8A2D\u5B9A"),
                UiText(L"An existing ip.ini was found. Recreate it?",
                       L"\u5DF2\u767C\u73FE\u5B89\u88DD ip.ini\uFF0C\u662F\u5426\u91CD\u5EFA\uFF1F"),
                MB_YESNO | MB_ICONQUESTION) != IDYES) {
            return false;
        }
    } else {
        if (ShowMessage(
                UiText(L"Initialize", L"\u521D\u59CB\u5316"),
                UiText(L"ip.ini was not found.\nA sample file named ip.ini.sample has been created.\n\nCreate it now?",
                       L"\u627E\u4E0D\u5230 ip.ini\u3002\n\u7A0B\u5F0F\u5DF2\u540C\u6642\u5E6B\u4F60\u5EFA\u7ACB ip.ini.sample \u53C3\u8003\u6A94\u3002\n\n\u8981\u73FE\u5728\u5E6B\u4F60\u5EFA\u7ACB\u55CE\uff1F"),
                MB_YESNO | MB_ICONQUESTION) != IDYES) {
            return false;
        }
    }

    std::wstring inputValue = L"192.168.1.100";
    std::wstring portValue;

    while (true) {
        std::wstring typedValue;
        if (!ShowTextInputDialog(
                UiText(L"Create Config", L"\u5EFA\u7ACB\u8A2D\u5B9A\u6A94"),
                UiText(L"Enter printer IP address.\nType usb to detect USB ports automatically.",
                       L"\u8ACB\u8F38\u5165\u5370\u8868\u6A5F IP \u4F4D\u5740\u3002\n\u8F38\u5165 usb \u53EF\u81EA\u52D5\u5075\u6E2C USB \u9023\u63A5\u57E0\u3002"),
                inputValue,
                typedValue)) {
            return false;
        }

        typedValue = Trim(typedValue);
        if (typedValue.empty()) {
            MessageBoxW(nullptr,
                        UiText(L"Please enter an IP address or usb.", L"\u8ACB\u8F38\u5165 IP \u4F4D\u5740\u6216 usb\u3002"),
                        UiText(L"Create Config", L"\u5EFA\u7ACB\u8A2D\u5B9A\u6A94"),
                        MB_OK | MB_ICONINFORMATION | MB_TOPMOST);
            continue;
        }

        if (IEquals(typedValue, L"usb")) {
            const auto usbPorts = GetUsbPortNames();
            if (usbPorts.empty()) {
                MessageBoxW(nullptr,
                            UiText(L"No USB printer ports were found.", L"\u627E\u4E0D\u5230 USB \u5370\u8868\u6A5F\u9023\u63A5\u57E0\u3002"),
                            UiText(L"USB Detection", L"USB \u5075\u6E2C"),
                            MB_OK | MB_ICONERROR | MB_TOPMOST);
                inputValue = typedValue;
                continue;
            }

            if (usbPorts.size() == 1) {
                portValue = usbPorts.front();
            } else {
                if (!ShowSelectionDialog(
                        UiText(L"Select USB Port", L"\u9078\u64C7 USB \u9023\u63A5\u57E0"),
                        UiText(L"Multiple USB printer ports were found. Please select one.",
                               L"\u5075\u6E2C\u5230\u591A\u500B USB \u5370\u8868\u6A5F\u9023\u63A5\u57E0\uff0C\u8ACB\u9078\u64C7\u4E00\u500B\u3002"),
                        usbPorts,
                        portValue)) {
                    return false;
                }
            }
            break;
        }

        portValue = typedValue;
        break;
    }

    const auto rawCandidates = BuildPrinterModelCandidates();
    const auto modelCandidates = FilterModelCandidatesForDisplay(rawCandidates);
    if (modelCandidates.empty()) {
        ShowErrorWithLog(
            UiText(L"Error", L"\u932F\u8AA4"),
            UiText(L"No printer models could be parsed from INF files in this folder.",
                   L"\u7121\u6CD5\u5F9E\u9019\u500B\u8CC7\u6599\u593E\u4E2D\u7684 INF \u6A94\u89E3\u6790\u51FA\u5370\u8868\u6A5F\u578B\u865F\u3002"));
        return false;
    }

    std::wstring modelName;
    fs::path selectedInf;
    if (modelCandidates.size() == 1) {
        modelName = modelCandidates.front().first;
        selectedInf = modelCandidates.front().second;
    } else {
        std::vector<std::wstring> options;
        options.reserve(modelCandidates.size());
        for (const auto& candidate : modelCandidates) {
            options.push_back(candidate.first);
        }

        if (!ShowSelectionDialog(
                UiText(L"Select Printer Model", L"\u9078\u64C7\u5370\u8868\u6A5F\u578B\u865F"),
                UiText(L"Multiple printer models were found. Please select one.",
                       L"\u5075\u6E2C\u5230\u591A\u500B\u5370\u8868\u6A5F\u578B\u865F\uff0C\u8ACB\u9078\u64C7\u4E00\u500B\u3002"),
                options,
                modelName)) {
            return false;
        }

        for (const auto& candidate : modelCandidates) {
            if (candidate.first == modelName) {
                selectedInf = candidate.second;
                break;
            }
        }
    }

    if (modelName.empty() || selectedInf.empty()) {
        ShowErrorWithLog(
            UiText(L"Error", L"\u932F\u8AA4"),
            UiText(L"Unable to determine the selected printer model or INF file.",
                   L"\u7121\u6CD5\u78BA\u5B9A\u4F60\u9078\u64C7\u7684\u5370\u8868\u6A5F\u578B\u865F\u6216 INF \u6A94\u3002"));
        return false;
    }

    config.mode = L"ip";
    config.portValue = portValue;
    config.printerName = modelName;
    config.driverName = modelName;
    config.infName = selectedInf.filename().wstring();
    config.flags = L"100";

    const std::wstring iniText =
        config.mode + L"," +
        config.portValue + L"," +
        config.printerName + L"," +
        config.driverName + L"," +
        config.infName + L"," +
        config.flags + L"\r\n" +
        L"lang=auto\r\n";

    if (!WriteTextFileAcp(g_baseDir / L"ip.ini", iniText)) {
        ShowErrorWithLog(
            UiText(L"Error", L"\u932F\u8AA4"),
            UiText(L"Failed to create ip.ini.", L"\u5EFA\u7ACB ip.ini \u5931\u6557\u3002"));
        return false;
    }

    ShowMessage(
        UiText(L"Config Created", L"\u5EFA\u7ACB\u5B8C\u6210"),
        UiText(L"ip.ini has been created successfully.\n\n", L"ip.ini \u5EFA\u7ACB\u6210\u529F\u3002\n\n") + BuildPrinterInfoMessage(config),
        MB_OK | MB_ICONINFORMATION);

    installNow = ShowMessage(
        UiText(L"Install Now", L"\u7ACB\u5373\u5B89\u88DD"),
        UiText(L"Configuration created.\n\nInstall this printer now?",
               L"\u8A2D\u5B9A\u6A94\u5DF2\u5EFA\u7ACB\u3002\n\n\u8981\u7ACB\u5373\u5B89\u88DD\u9019\u53F0\u5370\u8868\u6A5F\u55CE\uff1F"),
        MB_YESNO | MB_ICONQUESTION) == IDYES;

    return true;
}

std::wstring ResolvePortName(const std::wstring& portValue) {
    if (StartsWithI(portValue, L"USB")) {
        return portValue;
    }
    return L"IP_" + portValue;
}

bool PortExists(const std::wstring& portName) {
    DWORD needed = 0;
    DWORD returned = 0;
    EnumPortsW(nullptr, 1, nullptr, 0, &needed, &returned);
    if (needed == 0) {
        return false;
    }

    std::vector<BYTE> buffer(needed);
    if (!EnumPortsW(nullptr, 1, buffer.data(), needed, &needed, &returned)) {
        return false;
    }

    const auto* ports = reinterpret_cast<PORT_INFO_1W*>(buffer.data());
    for (DWORD i = 0; i < returned; ++i) {
        if (ports[i].pName && IEquals(ports[i].pName, portName)) {
            return true;
        }
    }
    return false;
}

std::wstring EscapeForPowerShellSingleQuoted(std::wstring text) {
    size_t pos = 0;
    while ((pos = text.find(L'\'', pos)) != std::wstring::npos) {
        text.insert(pos, L"'");
        pos += 2;
    }
    return text;
}

fs::path FindPrintingAdminScript(const std::wstring& scriptName) {
    wchar_t windir[MAX_PATH] = {};
    if (!GetEnvironmentVariableW(L"WINDIR", windir, MAX_PATH)) {
        return {};
    }

    const fs::path base = fs::path(windir) / L"System32" / L"Printing_Admin_Scripts";
    std::error_code ec;
    if (!fs::exists(base, ec)) {
        return {};
    }

    std::vector<std::wstring> preferred;
    wchar_t localeName[LOCALE_NAME_MAX_LENGTH] = {};
    if (GetUserDefaultLocaleName(localeName, LOCALE_NAME_MAX_LENGTH) > 0) {
        preferred.emplace_back(localeName);
    }
    preferred.emplace_back(L"en-US");

    for (const auto& folder : preferred) {
        const fs::path candidate = base / folder / scriptName;
        if (fs::exists(candidate, ec)) {
            return candidate;
        }
    }

    for (const auto& entry : fs::directory_iterator(base, ec)) {
        if (ec || !entry.is_directory()) {
            continue;
        }
        const fs::path candidate = entry.path() / scriptName;
        if (fs::exists(candidate, ec)) {
            return candidate;
        }
    }

    const fs::path direct = base / scriptName;
    if (fs::exists(direct, ec)) {
        return direct;
    }
    return {};
}

bool EnsureTcpIpPort(const std::wstring& ipAddress) {
    const std::wstring portName = ResolvePortName(ipAddress);
    if (PortExists(portName)) {
        return true;
    }

    const std::wstring psCommand =
        L"$ErrorActionPreference='Stop';"
        L"Add-PrinterPort -Name '" + EscapeForPowerShellSingleQuoted(portName) +
        L"' -PrinterHostAddress '" + EscapeForPowerShellSingleQuoted(ipAddress) + L"' -PortNumber 9100";

    DWORD exitCode = 0;
    RunProcess(L"powershell.exe",
        {L"-NoProfile", L"-ExecutionPolicy", L"Bypass", L"-Command", psCommand},
        exitCode,
        120000);
    if (PortExists(portName)) {
        return true;
    }

    const fs::path prnPort = FindPrintingAdminScript(L"prnport.vbs");
    if (!prnPort.empty()) {
        RunProcess(L"cscript.exe",
            {L"//nologo", prnPort.wstring(), L"-a", L"-r", portName, L"-h", ipAddress, L"-o", L"raw", L"-n", L"9100"},
            exitCode,
            120000);
        if (PortExists(portName)) {
            return true;
        }
    }

    Log(L"Unable to create port " + portName);
    return PortExists(portName);
}

bool PrinterExists(const std::wstring& printerName) {
    DWORD needed = 0;
    DWORD returned = 0;
    EnumPrintersW(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, nullptr, 4, nullptr, 0, &needed, &returned);
    if (needed == 0) {
        return false;
    }

    std::vector<BYTE> buffer(needed);
    if (!EnumPrintersW(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, nullptr, 4, buffer.data(), needed, &needed, &returned)) {
        return false;
    }

    const auto* info = reinterpret_cast<PRINTER_INFO_4W*>(buffer.data());
    for (DWORD i = 0; i < returned; ++i) {
        if (info[i].pPrinterName && IEquals(info[i].pPrinterName, printerName)) {
            return true;
        }
    }
    return false;
}

bool DeletePrinterByName(const std::wstring& printerName) {
    HANDLE printer = nullptr;
    PRINTER_DEFAULTSW defaults{};
    defaults.DesiredAccess = PRINTER_ACCESS_ADMINISTER;
    if (!OpenPrinterW(const_cast<LPWSTR>(printerName.c_str()), &printer, &defaults)) {
        const DWORD errorCode = GetLastError();
        if (errorCode == ERROR_INVALID_PRINTER_NAME || errorCode == ERROR_FILE_NOT_FOUND) {
            return true;
        }
        Log(L"OpenPrinter delete failed: " + FormatWin32Error(errorCode));
        return false;
    }

    const BOOL deleted = DeletePrinter(printer);
    const DWORD errorCode = deleted ? ERROR_SUCCESS : GetLastError();
    ClosePrinter(printer);
    if (!deleted) {
        Log(L"DeletePrinter failed: " + FormatWin32Error(errorCode));
        return false;
    }
    return true;
}

bool WaitForPrinterState(const std::wstring& printerName, bool shouldExist, int timeoutSeconds = 20) {
    for (int i = 0; i < timeoutSeconds; ++i) {
        if (PrinterExists(printerName) == shouldExist) {
            return true;
        }
        SleepWithMessages(1000);
    }
    return PrinterExists(printerName) == shouldExist;
}

std::wstring FindInstalledDriverName(const std::wstring& driverName) {
    DWORD needed = 0;
    DWORD returned = 0;
    EnumPrinterDriversW(nullptr, nullptr, 2, nullptr, 0, &needed, &returned);
    if (needed == 0) {
        return L"";
    }

    std::vector<BYTE> buffer(needed);
    if (!EnumPrinterDriversW(nullptr, nullptr, 2, buffer.data(), needed, &needed, &returned)) {
        Log(L"EnumPrinterDrivers failed: " + FormatWin32Error(GetLastError()));
        return L"";
    }

    const auto* drivers = reinterpret_cast<DRIVER_INFO_2W*>(buffer.data());
    for (DWORD i = 0; i < returned; ++i) {
        if (!drivers[i].pName) {
            continue;
        }
        const std::wstring installed = drivers[i].pName;
        if (IEquals(installed, driverName) ||
            StartsWithI(installed, driverName) ||
            StartsWithI(driverName, installed)) {
            return installed;
        }
    }
    return L"";
}

bool DriverExists(const std::wstring& driverName) {
    return !FindInstalledDriverName(driverName).empty();
}

bool WaitForDriver(const std::wstring& driverName, int timeoutSeconds = 45) {
    for (int i = 0; i < timeoutSeconds; ++i) {
        if (DriverExists(driverName)) {
            return true;
        }
        SleepWithMessages(1000);
    }
    return DriverExists(driverName);
}

std::wstring GetPrintUiArchitecture() {
    const std::wstring arch = GetArchitectureLabel();
    if (IEquals(arch, L"x64")) {
        return L"x64";
    }
    if (IEquals(arch, L"x86")) {
        return L"x86";
    }
    if (IEquals(arch, L"ARM64")) {
        return L"ARM64";
    }
    return L"x64";
}

bool AttemptDriverInstallWithInf(const fs::path& infPath, const std::wstring& driverName) {
    DWORD exitCode = 0;

    RunProcess(L"pnputil.exe", {L"/add-driver", infPath.wstring(), L"/install"}, exitCode, 120000);
    if (WaitForDriver(driverName, 8)) {
        return true;
    }

    RunProcess(L"rundll32.exe",
        {L"printui.dll,PrintUIEntry", L"/ia", L"/m", driverName, L"/f", infPath.wstring(), L"/q"},
        exitCode,
        120000);
    if (WaitForDriver(driverName, 15)) {
        return true;
    }

    RunProcess(L"rundll32.exe",
        {L"printui.dll,PrintUIEntry", L"/ia", L"/m", driverName, L"/f", infPath.wstring(),
         L"/h", GetPrintUiArchitecture(), L"/v", L"Type 3 - User Mode", L"/q"},
        exitCode,
        120000);

    return WaitForDriver(driverName, 15);
}

std::vector<fs::path> FindCandidateInfsForDriver(const Config& config) {
    std::vector<fs::path> candidates;
    std::set<std::wstring> seen;

    auto addUnique = [&](const fs::path& path) {
        const std::wstring key = ToLowerCopy(path.wstring());
        if (seen.insert(key).second) {
            candidates.push_back(path);
        }
    };

    const fs::path preferred = g_baseDir / config.infName;
    if (fs::exists(preferred)) {
        addUnique(preferred);
    }

    const auto infFiles = FindInfFiles();
    for (const auto& infPath : infFiles) {
        if (!IsLikelyPrinterInf(infPath)) {
            continue;
        }
        const std::wstring content = ReadTextFile(infPath);
        if (ContainsI(content, config.driverName)) {
            addUnique(infPath);
        }
    }

    if (candidates.empty()) {
        for (const auto& infPath : infFiles) {
            if (IsLikelyPrinterInf(infPath)) {
                addUnique(infPath);
            }
        }
    }

    return candidates;
}

bool EnsureDriverInstalled(const Config& config) {
    const std::wstring installed = FindInstalledDriverName(config.driverName);
    if (!installed.empty()) {
        Log(L"Driver already installed: " + installed);
        return true;
    }

    const auto candidates = FindCandidateInfsForDriver(config);
    for (const auto& infPath : candidates) {
        Log(L"Trying INF: " + infPath.wstring());
        if (AttemptDriverInstallWithInf(infPath, config.driverName)) {
            return true;
        }
    }
    return DriverExists(config.driverName);
}

bool AddPrinterQueue(const std::wstring& printerName,
                     const std::wstring& driverName,
                     const std::wstring& portName,
                     bool shared,
                     DWORD* lastError = nullptr) {
    PRINTER_INFO_2W info{};
    info.pPrinterName = const_cast<LPWSTR>(printerName.c_str());
    info.pPortName = const_cast<LPWSTR>(portName.c_str());
    info.pDriverName = const_cast<LPWSTR>(driverName.c_str());
    info.pPrintProcessor = const_cast<LPWSTR>(L"WinPrint");
    info.pDatatype = const_cast<LPWSTR>(L"RAW");
    info.Attributes = PRINTER_ATTRIBUTE_LOCAL | (shared ? PRINTER_ATTRIBUTE_SHARED : 0);
    if (shared) {
        info.pShareName = const_cast<LPWSTR>(printerName.c_str());
    }

    HANDLE printer = AddPrinterW(nullptr, 2, reinterpret_cast<LPBYTE>(&info));
    if (!printer) {
        const DWORD errorCode = GetLastError();
        if (lastError) {
            *lastError = errorCode;
        }
        Log(L"AddPrinter failed: " + FormatWin32Error(errorCode));
        return false;
    }

    ClosePrinter(printer);
    if (lastError) {
        *lastError = ERROR_SUCCESS;
    }
    return true;
}

bool TryCreatePrinterQueueWithPrnMngr(const std::wstring& printerName, const std::wstring& driverName, const std::wstring& portName) {
    const fs::path prnMngr = FindPrintingAdminScript(L"prnmngr.vbs");
    if (prnMngr.empty()) {
        return false;
    }

    DWORD exitCode = 0;
    RunProcess(L"cscript.exe",
        {L"//nologo", prnMngr.wstring(), L"-a", L"-p", printerName, L"-m", driverName, L"-r", portName},
        exitCode,
        120000);

    if (exitCode == 0) {
        SleepWithMessages(800);
    }
    return WaitForPrinterState(printerName, true, 10);
}

bool TryCreatePrinterQueueWithPrintUi(const fs::path& infPath,
                                      const std::wstring& printerName,
                                      const std::wstring& portName,
                                      const std::wstring& modelName) {
    if (Trim(modelName).empty()) {
        return false;
    }

    DWORD exitCode = 0;
    RunProcess(L"rundll32.exe",
        {L"printui.dll,PrintUIEntry", L"/if", L"/b", printerName, L"/f", infPath.wstring(),
         L"/r", portName, L"/m", modelName, L"/z", L"/q"},
        exitCode,
        120000);

    if (exitCode == 0) {
        SleepWithMessages(1200);
    }
    return WaitForPrinterState(printerName, true, 12);
}

bool EnsurePrinterCreated(const Config& config, bool reinstall, const std::wstring& resolvedDriverName) {
    const std::wstring portName = ResolvePortName(config.portValue);
    const bool shared = config.flags.size() >= 2 && config.flags[1] == L'1';

    if (reinstall || PrinterExists(config.printerName)) {
        DeletePrinterByName(config.printerName);
        WaitForPrinterState(config.printerName, false, 20);
    }

    for (int attempt = 0; attempt < 3; ++attempt) {
        DWORD addPrinterError = ERROR_SUCCESS;
        if (AddPrinterQueue(config.printerName, resolvedDriverName, portName, shared, &addPrinterError)) {
            return WaitForPrinterState(config.printerName, true, 10);
        }

        if (addPrinterError == ERROR_PRINTER_ALREADY_EXISTS) {
            DeletePrinterByName(config.printerName);
            WaitForPrinterState(config.printerName, false, 10);
        } else if (addPrinterError == ERROR_UNKNOWN_PORT) {
            if (!StartsWithI(config.portValue, L"USB")) {
                EnsureTcpIpPort(config.portValue);
            }
        } else if (addPrinterError == ERROR_UNKNOWN_PRINTER_DRIVER) {
            EnsureDriverInstalled(config);
        }

        SleepWithMessages(2000);
    }

    if (TryCreatePrinterQueueWithPrnMngr(config.printerName, resolvedDriverName, portName)) {
        return true;
    }

    const auto candidates = FindCandidateInfsForDriver(config);
    for (const auto& infPath : candidates) {
        if (TryCreatePrinterQueueWithPrintUi(infPath, config.printerName, portName, resolvedDriverName)) {
            return true;
        }
        if (!IEquals(resolvedDriverName, config.driverName) &&
            TryCreatePrinterQueueWithPrintUi(infPath, config.printerName, portName, config.driverName)) {
            return true;
        }
    }

    return PrinterExists(config.printerName);
}

bool RestorePrinterSettings(const std::wstring& printerName) {
    const fs::path datPath = g_baseDir / L"set.dat";
    if (!fs::exists(datPath)) {
        return true;
    }

    DWORD exitCode = 0;
    RunProcess(L"rundll32.exe",
        {L"printui.dll,PrintUIEntry", L"/Sr", L"/n", printerName, L"/a", datPath.wstring()},
        exitCode,
        120000);
    return exitCode == 0;
}

bool BackupPrinterSettings(const std::wstring& printerName) {
    const fs::path datPath = g_baseDir / L"set.dat";
    DWORD exitCode = 0;
    RunProcess(L"rundll32.exe",
        {L"printui.dll,PrintUIEntry", L"/Ss", L"/n", printerName, L"/a", datPath.wstring()},
        exitCode,
        120000);
    return exitCode == 0;
}

bool PrintTestPage(const std::wstring& printerName) {
    DWORD exitCode = 0;
    RunProcess(L"rundll32.exe",
        {L"printui.dll,PrintUIEntry", L"/k", L"/n", printerName},
        exitCode,
        120000);
    return exitCode == 0;
}

bool SetPrinterAsDefault(const std::wstring& printerName) {
    if (!SetDefaultPrinterW(printerName.c_str())) {
        Log(L"SetDefaultPrinter failed: " + FormatWin32Error(GetLastError()));
        return false;
    }
    return true;
}

void OpenPrintersFolder() {
    HINSTANCE instance = ShellExecuteW(
        nullptr,
        L"open",
        L"explorer.exe",
        L"shell:::{A8A91A66-3A7D-4424-8D24-04E180695C7A}",
        nullptr,
        SW_SHOWNORMAL);

    if (reinterpret_cast<INT_PTR>(instance) <= 32) {
        ShellExecuteW(nullptr, L"open", L"control.exe", L"/name Microsoft.DevicesAndPrinters", nullptr, SW_SHOWNORMAL);
    }
}

void OpenAddPrinterWizard() {
    ShellExecuteW(
        nullptr,
        L"open",
        L"rundll32.exe",
        L"printui.dll,PrintUIEntry /il",
        g_baseDir.c_str(),
        SW_SHOWNORMAL);
}

std::wstring BuildPrinterInfoMessage(const Config& config) {
    std::wstring portDisplay = config.portValue;
    if (!StartsWithI(config.portValue, L"USB")) {
        portDisplay += L"  (IP_" + config.portValue + L")";
    }
    return std::wstring(UiText(L"Printer: ", L"\u5370\u8868\u6A5F\uff1A")) + config.printerName +
           L"\n" + UiText(L"Port: ", L"\u9023\u63A5\u57E0\uff1A") + portDisplay +
           L"\nINF: " + config.infName;
}

bool PreparePort(const Config& config) {
    if (StartsWithI(config.portValue, L"USB")) {
        if (!PortExists(config.portValue)) {
            Log(L"USB port not found: " + config.portValue);
            return false;
        }
        return true;
    }
    return EnsureTcpIpPort(config.portValue);
}

bool InstallPrinterFlow(const Config& config, bool reinstall, bool setDefaultChoice) {
    Config working = config;
    Log(L"Install flow start. Printer=" + working.printerName + L", Driver=" + working.driverName + L", INF=" + working.infName);
    ShowProgressWindow(
        UiText(L"Installing Printer", L"\u6B63\u5728\u5B89\u88DD\u5370\u8868\u6A5F"),
        UiText(L"Starting installation...", L"\u6B63\u5728\u958B\u59CB\u5B89\u88DD\u2026"));

    if (!EnsureSpoolerRunning()) {
        CloseProgressWindow();
        ShowErrorWithLog(
            UiText(L"Error", L"\u932F\u8AA4"),
            UiText(L"Unable to start the Print Spooler service.",
                   L"\u7121\u6CD5\u555F\u52D5 Print Spooler \u670D\u52D9\u3002"));
        return false;
    }

    UpdateProgressWindow(UiText(L"Preparing printer port...", L"\u6B63\u5728\u6E96\u5099\u5370\u8868\u6A5F\u9023\u63A5\u57E0\u2026"), 10);
    if (!PreparePort(working)) {
        CloseProgressWindow();
        ShowErrorWithLog(
            UiText(L"Error", L"\u932F\u8AA4"),
            UiText(L"Unable to create or locate the printer port.",
                   L"\u7121\u6CD5\u5EFA\u7ACB\u6216\u627E\u5230\u5370\u8868\u6A5F\u9023\u63A5\u57E0\u3002"));
        return false;
    }

    if (FindCandidateInfsForDriver(working).empty()) {
        CloseProgressWindow();
        ShowErrorWithLog(
            UiText(L"Error", L"\u932F\u8AA4"),
            UiText(L"No usable INF files were found. Keep the EXE and driver files in the same folder.",
                   L"\u627E\u4E0D\u5230\u53EF\u7528\u7684 INF \u6A94\u3002\u8ACB\u78BA\u8A8D EXE \u8207\u9A45\u52D5\u6A94\u653E\u5728\u540C\u4E00\u500B\u8CC7\u6599\u593E\u3002"));
        return false;
    }

    UpdateProgressWindow(UiText(L"Importing printer driver...", L"\u6B63\u5728\u532F\u5165\u5370\u8868\u6A5F\u9A45\u52D5\u7A0B\u5F0F\u2026"), 30);
    if (!EnsureDriverInstalled(working)) {
        CloseProgressWindow();
        ShowErrorWithLog(
            UiText(L"Error", L"\u932F\u8AA4"),
            std::wstring(UiText(L"Driver import failed. Windows still cannot find driver: ",
                                 L"\u9A45\u52D5\u7A0B\u5F0F\u532F\u5165\u5931\u6557\uff0cWindows \u4ECD\u627E\u4E0D\u5230\u9019\u500B\u9A45\u52D5\u7A0B\u5F0F\uff1A")) + working.driverName);
        return false;
    }

    std::wstring resolvedDriver = FindInstalledDriverName(working.driverName);
    if (resolvedDriver.empty()) {
        resolvedDriver = working.driverName;
    }
    working.driverName = resolvedDriver;

    UpdateProgressWindow(UiText(L"Creating printer queue...", L"\u6B63\u5728\u5EFA\u7ACB\u5370\u8868\u6A5F\u4F47\u5217\u2026"), 70);
    if (!EnsurePrinterCreated(working, reinstall, resolvedDriver)) {
        CloseProgressWindow();
        OpenAddPrinterWizard();
        ShowErrorWithLog(
            UiText(L"Error", L"\u932F\u8AA4"),
            UiText(L"Printer queue creation failed. The Windows Add Printer wizard has been opened.",
                   L"\u5370\u8868\u6A5F\u4F47\u5217\u5EFA\u7ACB\u5931\u6557\u3002\u5DF2\u81EA\u52D5\u958B\u555F Windows \u65B0\u589E\u5370\u8868\u6A5F\u7CBE\u9748\u3002"));
        return false;
    }

    if (fs::exists(g_baseDir / L"set.dat")) {
        UpdateProgressWindow(UiText(L"Applying saved printer settings...", L"\u6B63\u5728\u5957\u7528\u5132\u5B58\u7684\u5370\u8868\u6A5F\u8A2D\u5B9A\u2026"), 85);
        if (!RestorePrinterSettings(working.printerName)) {
            Log(L"set.dat restore returned non-zero exit code.");
        }
    }

    if (setDefaultChoice) {
        UpdateProgressWindow(UiText(L"Setting default printer...", L"\u6B63\u5728\u8A2D\u70BA\u9810\u8A2D\u5370\u8868\u6A5F\u2026"), 90);
        SetPrinterAsDefault(working.printerName);
    }

    if (working.flags.size() >= 3 && working.flags[2] == L'1') {
        UpdateProgressWindow(UiText(L"Printing test page...", L"\u6B63\u5728\u5217\u5370\u6E2C\u8A66\u9801\u2026"), 95);
        PrintTestPage(working.printerName);
    }

    UpdateProgressWindow(UiText(L"Finishing installation...", L"\u6B63\u5728\u5B8C\u6210\u5B89\u88DD\u2026"), 100);
    CloseProgressWindow();
    OpenPrintersFolder();
    ShowMessage(
        UiText(L"Complete", L"\u5B8C\u6210"),
        std::wstring(L"[") + working.printerName + L"] " +
            UiText(L"installation completed.", L"\u5B89\u88DD\u5B8C\u6210\u3002"),
        MB_OK | MB_ICONINFORMATION);
    return true;
}
HWND g_mainWindow = nullptr;
HWND g_tabCtrl = nullptr;
HWND g_aboutPage = nullptr;
HWND g_deployPage = nullptr;
HFONT g_titleFont = nullptr;
HFONT g_linkFont = nullptr;
Config g_config;

constexpr int kTabControlId = 2001;
constexpr int kLangComboId = 2002;
constexpr int kLangLabelId = 2003;

constexpr int kAboutEditId = 2101;
constexpr int kAboutLinkId = 2102;
constexpr int kAboutSubTitleId = 2103;
constexpr int kAboutAuthorId = 2104;

constexpr int kDeployStatusTextId = 2201;
constexpr int kDeployGroupInfoId = 2202;
constexpr int kDeployInfoIpId = 2203;
constexpr int kDeployInfoNameId = 2204;
constexpr int kDeployInfoDriverId = 2205;
constexpr int kDeployInfoInfId = 2206;
constexpr int kDeployInfoFlagsId = 2207;
constexpr int kDeployBtnInstallId = 2208;
constexpr int kDeployBtnReinstallId = 2209;
constexpr int kDeployBtnBackupId = 2210;
constexpr int kDeployBtnRestoreId = 2211;
constexpr int kDeployBtnFolderId = 2212;
constexpr int kDeployBtnConfigId = 2213;

constexpr UINT WM_UPDATE_DEPLOY_UI = WM_USER + 101;

std::wstring GetAboutText() {
    if (g_appLanguage == AppLanguage::TraditionalChinese) {
        return std::wstring(
            L"PrtEasySetup\r\n"
            L"一站式印表機部署工具\r\n\r\n"
            L"版本：V1.2.0.0\r\n"
            L"版本類型：C++ 全新重製版\r\n"
            L"作者：Terence0816\r\n"
            L"GitHub：https://github.com/Terence0816/Printer-Setup-Tool\r\n\r\n"
            L"PrtEasySetup 是一套輕量化印表機部署工具，適合 IT 管理員、維護工程師、MSP 維護商，以及需要大量安裝印表機的環境使用。\r\n\r\n"
            L"本工具可協助自動化處理印表機部署流程，包含印表機驅動 INF 解析、TCP/IP 或 USB 連接埠建立、印表機安裝、部署設定檔建立，以及印表機偏好設定備份與還原。\r\n\r\n"
            L"主要功能：\r\n"
            L"* 智慧解析印表機 INF 驅動檔\r\n"
            L"* 支援 TCP/IP 印表機部署\r\n"
            L"* 支援 USB 印表機部署\r\n"
            L"* 支援 ip.ini 部署設定檔\r\n"
            L"* 偵測已安裝印表機並可選擇重新安裝\r\n"
            L"* 支援透過 set.dat 備份 / 還原印表機偏好設定\r\n"
            L"* 單一 EXE 可攜式設計\r\n"
            L"* 簡化 Windows 印表機安裝與維護流程\r\n\r\n"
            L"執行需求：\r\n"
            L"請使用系統管理員身分執行本程式。\r\n\r\n"
            L"重要檔案：\r\n"
            L"* ip.ini：印表機部署設定檔\r\n"
            L"* set.dat：印表機偏好設定備份檔\r\n\r\n"
            L"問題回報 / 建議：\r\n"
            L"請至 GitHub Issues 回報問題或提出建議。\r\n\r\n"
            L"免責聲明：\r\n"
            L"本工具依現況提供，建議正式大量部署前，先於目標環境進行測試。\r\n"
        );
    } else {
        return std::wstring(
            L"PrtEasySetup\r\n"
            L"All-in-One Printer Deployment Tool\r\n\r\n"
            L"Version: V1.2.0.0\r\n"
            L"Edition: Native C++ Rewrite\r\n"
            L"Author: Terence0816\r\n"
            L"GitHub: https://github.com/Terence0816/Printer-Setup-Tool\r\n\r\n"
            L"PrtEasySetup is a lightweight printer deployment utility designed for IT administrators, maintenance engineers, and MSP service providers.\r\n\r\n"
            L"This tool helps automate printer deployment tasks, including printer driver INF parsing, TCP/IP or USB printer port creation, printer installation, deployment profile generation, and printer preference backup / restore.\r\n\r\n"
            L"Main Features:\r\n"
            L"* Smart INF printer driver parsing\r\n"
            L"* TCP/IP printer deployment\r\n"
            L"* USB printer deployment support\r\n"
            L"* ip.ini deployment profile support\r\n"
            L"* Existing printer detection and reinstall handling\r\n"
            L"* Printer preference backup / restore using set.dat\r\n"
            L"* Portable single EXE design\r\n"
            L"* Designed for easier Windows printer setup and maintenance\r\n\r\n"
            L"Required Permission:\r\n"
            L"Please run this program as Administrator.\r\n\r\n"
            L"Important Files:\r\n"
            L"* ip.ini: Printer deployment profile\r\n"
            L"* set.dat: Printer preference backup file\r\n\r\n"
            L"Support / Feedback:\r\n"
            L"Please report issues or suggestions through GitHub Issues.\r\n\r\n"
            L"Disclaimer:\r\n"
            L"This software is provided as-is. Please test in your own environment before large-scale deployment.\r\n"
        );
    }
}

void RefreshAboutUI() {
    if (!g_aboutPage) return;
    HWND hSubTitle = GetDlgItem(g_aboutPage, kAboutSubTitleId);
    HWND hAuthor = GetDlgItem(g_aboutPage, kAboutAuthorId);
    HWND hEdit = GetDlgItem(g_aboutPage, kAboutEditId);
    HWND hLink = GetDlgItem(g_aboutPage, kAboutLinkId);

    std::wstring subTitle = UiText(
        L"All-in-One Printer Deployment Tool  |  Version: V1.2.0.0",
        L"一站式印表機部署工具  |  版本: V1.2.0.0"
    );
    if (hSubTitle) SetWindowTextW(hSubTitle, subTitle.c_str());

    std::wstring author = UiText(L"Author: Terence0816", L"作者: Terence0816");
    if (hAuthor) SetWindowTextW(hAuthor, author.c_str());

    if (hEdit) SetWindowTextW(hEdit, GetAboutText().c_str());

    std::wstring linkText = UiText(
        L"GitHub: Check for Updates",
        L"GitHub: 檢查是否有最新版本"
    );
    if (hLink) SetWindowTextW(hLink, linkText.c_str());
}

LRESULT CALLBACK AboutPageProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    switch (msg) {
    case WM_CREATE: {
        HWND hTitle = CreateWindowExW(0, L"STATIC", L"PrtEasySetup", WS_CHILD | WS_VISIBLE, 10, 10, 480, 28, hwnd, nullptr, nullptr, nullptr);
        if (g_titleFont) SendMessageW(hTitle, WM_SETFONT, reinterpret_cast<WPARAM>(g_titleFont), TRUE);

        HWND hSubTitle = CreateWindowExW(0, L"STATIC", L"", WS_CHILD | WS_VISIBLE, 10, 40, 480, 18, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kAboutSubTitleId)), nullptr, nullptr);
        SetControlFont(hSubTitle);

        HWND hAuthor = CreateWindowExW(0, L"STATIC", L"", WS_CHILD | WS_VISIBLE, 10, 60, 480, 18, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kAboutAuthorId)), nullptr, nullptr);
        SetControlFont(hAuthor);

        HWND hEdit = CreateWindowExW(WS_EX_CLIENTEDGE, L"EDIT", L"",
            WS_CHILD | WS_VISIBLE | WS_VSCROLL | ES_MULTILINE | ES_READONLY | ES_AUTOVSCROLL,
            10, 85, 480, 245, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kAboutEditId)), nullptr, nullptr);
        SetControlFont(hEdit);

        // 使用普通的 STATIC 控制項，並加上 SS_NOTIFY 接收點擊
        HWND hLink = CreateWindowExW(0, L"STATIC",
            L"",
            WS_CHILD | WS_VISIBLE | SS_NOTIFY,
            10, 340, 480, 20, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kAboutLinkId)), nullptr, nullptr);
        
        // 建立有底線的字型
        if (!g_linkFont) {
            LOGFONTW lfLink{};
            GetObjectW(GetStockObject(DEFAULT_GUI_FONT), sizeof(lfLink), &lfLink);
            lfLink.lfUnderline = TRUE;
            g_linkFont = CreateFontIndirectW(&lfLink);
        }
        if (g_linkFont) {
            SendMessageW(hLink, WM_SETFONT, reinterpret_cast<WPARAM>(g_linkFont), TRUE);
        } else {
            SetControlFont(hLink);
        }

        RefreshAboutUI();
        return 0;
    }
    case WM_COMMAND: {
        // 自訂 STATIC 超連結點擊事件
        if (LOWORD(wParam) == kAboutLinkId) {
            ShellExecuteW(nullptr, L"open", L"https://github.com/Terence0816/Printer-Setup-Tool", nullptr, nullptr, SW_SHOWNORMAL);
        }
        break;
    }
    case WM_SETCURSOR: {
        HWND hwndCursor = reinterpret_cast<HWND>(wParam);
        if (GetDlgCtrlID(hwndCursor) == kAboutLinkId) {
            SetCursor(LoadCursorW(nullptr, IDC_HAND));
            return TRUE;
        }
        break;
    }
    case WM_CTLCOLORSTATIC: {
        HWND ctrlHwnd = reinterpret_cast<HWND>(lParam);
        HDC hdc = reinterpret_cast<HDC>(wParam);
        if (GetDlgCtrlID(ctrlHwnd) == kAboutEditId) {
            SetBkColor(hdc, GetSysColor(COLOR_BTNFACE));
            return reinterpret_cast<LRESULT>(GetSysColorBrush(COLOR_BTNFACE));
        }
        if (GetDlgCtrlID(ctrlHwnd) == kAboutLinkId) {
            SetTextColor(hdc, RGB(0, 102, 204)); // 超連結藍色
            SetBkMode(hdc, TRANSPARENT);
            return reinterpret_cast<LRESULT>(GetSysColorBrush(COLOR_BTNFACE));
        }
        SetBkMode(hdc, TRANSPARENT);
        return reinterpret_cast<LRESULT>(GetSysColorBrush(COLOR_BTNFACE));
    }
    default:
        break;
    }
    return DefWindowProcW(hwnd, msg, wParam, lParam);
}

struct DeployPageControls {
    HWND hStatusText = nullptr;
    HWND hGroupBox = nullptr;
    HWND hLabelIp = nullptr;
    HWND hLabelName = nullptr;
    HWND hLabelDriver = nullptr;
    HWND hLabelInf = nullptr;
    HWND hLabelFlags = nullptr;
    HWND hBtnInstall = nullptr;
    HWND hBtnReinstall = nullptr;
    HWND hBtnBackup = nullptr;
    HWND hBtnRestore = nullptr;
    HWND hBtnFolder = nullptr;
    HWND hBtnConfig = nullptr;
} g_deployCtrls;

void RefreshDeployUI() {
    bool iniExists = fs::exists(g_baseDir / L"ip.ini");
    bool hasConfig = false;
    if (iniExists) {
        hasConfig = ReadConfig(g_config);
    }

    if (g_deployCtrls.hGroupBox) {
        SetWindowTextW(g_deployCtrls.hGroupBox, UiText(L"Profile Settings", L"設定檔內容"));
    }

    if (iniExists && hasConfig) {
        std::wstring statusStr = UiText(
            L"Profile Status: Profile loaded successfully (ip.ini)",
            L"設定檔狀態：已成功載入印表機設定 (ip.ini)"
        );
        SetWindowTextW(g_deployCtrls.hStatusText, statusStr.c_str());

        std::wstring ipVal = UiText(L"IP / Port: ", L"IP / 連接埠: ") + g_config.portValue;
        std::wstring nameVal = UiText(L"Printer Name: ", L"印表機名稱: ") + g_config.printerName;
        std::wstring driverVal = UiText(L"Driver Name: ", L"驅動程式名稱: ") + g_config.driverName;
        std::wstring infVal = UiText(L"Driver INF: ", L"驅動 INF 檔案: ") + g_config.infName;
        
        std::wstring defText = g_config.flags.size() >= 1 && g_config.flags[0] == L'1' ? UiText(L"Yes", L"是") : UiText(L"No", L"否");
        std::wstring shareText = g_config.flags.size() >= 2 && g_config.flags[1] == L'1' ? UiText(L"Yes", L"是") : UiText(L"No", L"否");
        std::wstring testText = g_config.flags.size() >= 3 && g_config.flags[2] == L'1' ? UiText(L"Yes", L"是") : UiText(L"No", L"否");
        std::wstring flagsVal = UiText(L"Flags: ", L"屬性旗標: ") + g_config.flags + L" (" +
            UiText(L"Default: ", L"預設: ") + defText + L" | " +
            UiText(L"Shared: ", L"共享: ") + shareText + L" | " +
            UiText(L"Test Page: ", L"測試頁: ") + testText + L")";

        SetWindowTextW(g_deployCtrls.hLabelIp, ipVal.c_str());
        SetWindowTextW(g_deployCtrls.hLabelName, nameVal.c_str());
        SetWindowTextW(g_deployCtrls.hLabelDriver, driverVal.c_str());
        SetWindowTextW(g_deployCtrls.hLabelInf, infVal.c_str());
        SetWindowTextW(g_deployCtrls.hLabelFlags, flagsVal.c_str());

        // 偵測印表機是否已安裝
        const bool printerInstalled = PrinterExists(g_config.printerName);

        EnableWindow(g_deployCtrls.hBtnInstall, TRUE);
        
        // 只有偵測到已安裝印表機時才啟用「重新安裝」與「備份偏好設定」
        EnableWindow(g_deployCtrls.hBtnReinstall, printerInstalled ? TRUE : FALSE);
        EnableWindow(g_deployCtrls.hBtnBackup, printerInstalled ? TRUE : FALSE);
        
        // 「還原偏好設定」必須在印表機已安裝「且」set.dat 檔案存在時才啟用
        bool hasDat = fs::exists(g_baseDir / L"set.dat");
        EnableWindow(g_deployCtrls.hBtnRestore, (printerInstalled && hasDat) ? TRUE : FALSE);
    } else {
        std::wstring statusStr = iniExists ? 
            UiText(L"Profile Status: ip.ini exists but format is invalid!", L"設定檔狀態：ip.ini 已存在但格式不正確！") :
            UiText(L"Profile Status: ip.ini profile not found", L"設定檔狀態：未找到 ip.ini 設定檔");
        SetWindowTextW(g_deployCtrls.hStatusText, statusStr.c_str());

        SetWindowTextW(g_deployCtrls.hLabelIp, UiText(L"IP / Port: -", L"IP / 連接埠: -"));
        SetWindowTextW(g_deployCtrls.hLabelName, UiText(L"Printer Name: -", L"印表機名稱: -"));
        SetWindowTextW(g_deployCtrls.hLabelDriver, UiText(L"Driver Name: -", L"驅動程式名稱: -"));
        SetWindowTextW(g_deployCtrls.hLabelInf, UiText(L"Driver INF: -", L"驅動 INF 檔案: -"));
        SetWindowTextW(g_deployCtrls.hLabelFlags, UiText(L"Flags: -", L"屬性旗標: -"));

        EnableWindow(g_deployCtrls.hBtnInstall, FALSE);
        EnableWindow(g_deployCtrls.hBtnReinstall, FALSE);
        EnableWindow(g_deployCtrls.hBtnBackup, FALSE);
        EnableWindow(g_deployCtrls.hBtnRestore, FALSE);
    }

    SetWindowTextW(g_deployCtrls.hBtnInstall, UiText(L"Deploy Printer", L"開始部署印表機"));
    SetWindowTextW(g_deployCtrls.hBtnReinstall, UiText(L"Reinstall", L"重新安裝印表機"));
    SetWindowTextW(g_deployCtrls.hBtnConfig, UiText(L"Configure Profile", L"建立/編輯設定檔"));
    SetWindowTextW(g_deployCtrls.hBtnBackup, UiText(L"Backup Settings", L"備份偏好設定"));
    SetWindowTextW(g_deployCtrls.hBtnRestore, UiText(L"Restore Settings", L"還原偏好設定"));
    SetWindowTextW(g_deployCtrls.hBtnFolder, UiText(L"Printers List", L"開啟印表機列表"));
}

void OnBtnInstallClicked(HWND parent) {
    if (!ReadConfig(g_config)) {
        ShowErrorWithLog(UiText(L"Error", L"錯誤"), UiText(L"ip.ini is missing or invalid.", L"找不到 ip.ini 或格式不正確。"));
        return;
    }
    const std::wstring infoMessage = BuildPrinterInfoMessage(g_config);
    if (ShowMessage(
            UiText(L"Install Confirmation", L"安裝確認"),
            std::wstring(UiText(L"Install this printer?\n\n", L"要安裝以下印表機嗎？\n\n")) + infoMessage,
            MB_YESNO | MB_ICONQUESTION) != IDYES) {
        return;
    }

    const bool setDefaultChoice =
        ShowMessage(
            UiText(L"Default Printer", L"預設印表機"),
            std::wstring(UiText(L"Set this printer as default?\n\n", L"要將這台印表機設為預設嗎？\n\n")) + infoMessage,
            MB_YESNO | MB_ICONQUESTION) == IDYES;

    InstallPrinterFlow(g_config, false, setDefaultChoice);
}

void OnBtnReinstallClicked(HWND parent) {
    if (!ReadConfig(g_config)) return;
    const std::wstring infoMessage = BuildPrinterInfoMessage(g_config);
    const bool setDefaultChoice =
        ShowMessage(
            UiText(L"Default Printer", L"預設印表機"),
            std::wstring(UiText(L"After reinstall, set this printer as default?\n\n",
                                L"重新安裝後，要將這台印表機設為預設嗎？\n\n")) + infoMessage,
            MB_YESNO | MB_ICONQUESTION) == IDYES;
    InstallPrinterFlow(g_config, true, setDefaultChoice);
}

void OnBtnBackupClicked(HWND parent) {
    if (!ReadConfig(g_config)) return;
    if (BackupPrinterSettings(g_config.printerName)) {
        ShowMessage(
            UiText(L"Complete", L"完成"),
            UiText(L"set.dat backup completed.", L"set.dat 備份完成。"),
            MB_OK | MB_ICONINFORMATION);
    } else {
        ShowErrorWithLog(
            UiText(L"Error", L"錯誤"),
            UiText(L"set.dat backup failed.", L"set.dat 備份失敗。"));
    }
}

void OnBtnRestoreClicked(HWND parent) {
    if (!ReadConfig(g_config)) return;
    if (RestorePrinterSettings(g_config.printerName)) {
        OpenPrintersFolder();
        ShowMessage(
            UiText(L"Complete", L"完成"),
            UiText(L"set.dat restore completed.", L"set.dat 還原完成。"),
            MB_OK | MB_ICONINFORMATION);
    } else {
        ShowErrorWithLog(
            UiText(L"Error", L"錯誤"),
            UiText(L"set.dat restore failed.", L"set.dat 還原失敗。"));
    }
}

void OnBtnFolderClicked() {
    OpenPrintersFolder();
}

void OnBtnConfigClicked(HWND parent) {
    bool installNow = false;
    if (BuildConfigInteractively(g_config, installNow)) {
        ReadConfig(g_config);
        SendMessageW(g_deployPage, WM_UPDATE_DEPLOY_UI, 0, 0);
        if (installNow) {
            InstallPrinterFlow(g_config, false, true);
            SendMessageW(g_deployPage, WM_UPDATE_DEPLOY_UI, 0, 0);
        }
    }
}

LRESULT CALLBACK DeployPageProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    switch (msg) {
    case WM_CREATE: {
        g_deployCtrls.hStatusText = CreateWindowExW(0, L"STATIC", L"", WS_CHILD | WS_VISIBLE, 10, 10, 480, 20, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kDeployStatusTextId)), nullptr, nullptr);
        SetControlFont(g_deployCtrls.hStatusText);

        g_deployCtrls.hGroupBox = CreateWindowExW(0, L"BUTTON", L"", WS_CHILD | WS_VISIBLE | BS_GROUPBOX, 10, 35, 480, 165, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kDeployGroupInfoId)), nullptr, nullptr);
        SetControlFont(g_deployCtrls.hGroupBox);

        g_deployCtrls.hLabelIp = CreateWindowExW(0, L"STATIC", L"", WS_CHILD | WS_VISIBLE, 25, 55, 450, 18, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kDeployInfoIpId)), nullptr, nullptr);
        SetControlFont(g_deployCtrls.hLabelIp);

        g_deployCtrls.hLabelName = CreateWindowExW(0, L"STATIC", L"", WS_CHILD | WS_VISIBLE, 25, 80, 450, 18, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kDeployInfoNameId)), nullptr, nullptr);
        SetControlFont(g_deployCtrls.hLabelName);

        g_deployCtrls.hLabelDriver = CreateWindowExW(0, L"STATIC", L"", WS_CHILD | WS_VISIBLE, 25, 105, 450, 18, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kDeployInfoDriverId)), nullptr, nullptr);
        SetControlFont(g_deployCtrls.hLabelDriver);

        g_deployCtrls.hLabelInf = CreateWindowExW(0, L"STATIC", L"", WS_CHILD | WS_VISIBLE, 25, 130, 450, 18, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kDeployInfoInfId)), nullptr, nullptr);
        SetControlFont(g_deployCtrls.hLabelInf);

        g_deployCtrls.hLabelFlags = CreateWindowExW(0, L"STATIC", L"", WS_CHILD | WS_VISIBLE, 25, 155, 450, 18, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kDeployInfoFlagsId)), nullptr, nullptr);
        SetControlFont(g_deployCtrls.hLabelFlags);

        g_deployCtrls.hBtnInstall = CreateWindowExW(0, L"BUTTON", L"", WS_CHILD | WS_VISIBLE | WS_TABSTOP, 15, 215, 150, 30, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kDeployBtnInstallId)), nullptr, nullptr);
        SetControlFont(g_deployCtrls.hBtnInstall);

        g_deployCtrls.hBtnReinstall = CreateWindowExW(0, L"BUTTON", L"", WS_CHILD | WS_VISIBLE | WS_TABSTOP, 175, 215, 150, 30, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kDeployBtnReinstallId)), nullptr, nullptr);
        SetControlFont(g_deployCtrls.hBtnReinstall);

        g_deployCtrls.hBtnConfig = CreateWindowExW(0, L"BUTTON", L"", WS_CHILD | WS_VISIBLE | WS_TABSTOP, 335, 215, 150, 30, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kDeployBtnConfigId)), nullptr, nullptr);
        SetControlFont(g_deployCtrls.hBtnConfig);

        g_deployCtrls.hBtnBackup = CreateWindowExW(0, L"BUTTON", L"", WS_CHILD | WS_VISIBLE | WS_TABSTOP, 15, 255, 150, 30, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kDeployBtnBackupId)), nullptr, nullptr);
        SetControlFont(g_deployCtrls.hBtnBackup);

        g_deployCtrls.hBtnRestore = CreateWindowExW(0, L"BUTTON", L"", WS_CHILD | WS_VISIBLE | WS_TABSTOP, 175, 255, 150, 30, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kDeployBtnRestoreId)), nullptr, nullptr);
        SetControlFont(g_deployCtrls.hBtnRestore);

        g_deployCtrls.hBtnFolder = CreateWindowExW(0, L"BUTTON", L"", WS_CHILD | WS_VISIBLE | WS_TABSTOP, 335, 255, 150, 30, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kDeployBtnFolderId)), nullptr, nullptr);
        SetControlFont(g_deployCtrls.hBtnFolder);

        RefreshDeployUI();
        return 0;
    }
    case WM_COMMAND: {
        int wmId = LOWORD(wParam);
        switch (wmId) {
        case kDeployBtnInstallId: {
            OnBtnInstallClicked(hwnd);
            RefreshDeployUI();
            break;
        }
        case kDeployBtnReinstallId: {
            OnBtnReinstallClicked(hwnd);
            RefreshDeployUI();
            break;
        }
        case kDeployBtnConfigId: {
            OnBtnConfigClicked(hwnd);
            RefreshDeployUI();
            break;
        }
        case kDeployBtnBackupId: {
            OnBtnBackupClicked(hwnd);
            RefreshDeployUI();
            break;
        }
        case kDeployBtnRestoreId: {
            OnBtnRestoreClicked(hwnd);
            RefreshDeployUI();
            break;
        }
        case kDeployBtnFolderId: {
            OnBtnFolderClicked();
            break;
        }
        default:
            break;
        }
        return 0;
    }
    case WM_UPDATE_DEPLOY_UI: {
        RefreshDeployUI();
        return 0;
    }
    case WM_CTLCOLORSTATIC: {
        HDC hdc = reinterpret_cast<HDC>(wParam);
        SetBkMode(hdc, TRANSPARENT);
        return reinterpret_cast<LRESULT>(GetSysColorBrush(COLOR_BTNFACE));
    }
    default:
        break;
    }
    return DefWindowProcW(hwnd, msg, wParam, lParam);
}

void SaveLanguageSettingToIni() {
    const fs::path iniPath = g_baseDir / L"ip.ini";
    std::wstring text = ReadTextFile(iniPath);
    std::wstring langVal = (g_appLanguage == AppLanguage::TraditionalChinese) ? L"zh" : L"en";

    if (text.empty()) {
        WriteTextFileAcp(iniPath, L"lang=" + langVal + L"\r\n");
        return;
    }

    auto lines = SplitLines(text);
    bool found = false;
    for (auto& line : lines) {
        std::wstring trimmed = Trim(line);
        if (trimmed.empty() || StartsWithI(trimmed, L"#") || StartsWithI(trimmed, L";")) {
            continue;
        }
        auto pos = trimmed.find(L'=');
        if (pos != std::wstring::npos) {
            std::wstring key = ToLowerCopy(Trim(trimmed.substr(0, pos)));
            if (key == L"lang" || key == L"language" || key == L"ui_lang") {
                line = trimmed.substr(0, pos + 1) + langVal;
                found = true;
                break;
            }
        }
    }

    std::wstring newText;
    for (const auto& line : lines) {
        newText += line + L"\r\n";
    }

    if (!found) {
        newText += L"lang=" + langVal + L"\r\n";
    }

    WriteTextFileAcp(iniPath, newText);
}

void RefreshMainTabUI() {
    if (!g_tabCtrl) return;
    TCITEMW tie{};
    tie.mask = TCIF_TEXT;
    
    tie.pszText = const_cast<LPWSTR>(UiText(L"Printer Deployment", L"印表機部署"));
    TabCtrl_SetItem(g_tabCtrl, 0, &tie);

    tie.pszText = const_cast<LPWSTR>(UiText(L"About", L"關於"));
    TabCtrl_SetItem(g_tabCtrl, 1, &tie);

    HWND hLabel = GetDlgItem(g_mainWindow, kLangLabelId);
    if (hLabel) {
        SetWindowTextW(hLabel, UiText(L"Language:", L"語言:"));
    }
}

void SwitchLanguage(AppLanguage lang) {
    g_appLanguage = lang;
    RefreshMainTabUI();
    RefreshAboutUI();
    if (g_deployPage) {
        SendMessageW(g_deployPage, WM_UPDATE_DEPLOY_UI, 0, 0);
    }
    SaveLanguageSettingToIni();

    // 解決 Z-order 重繪消失 bug：強迫重繪主視窗和所有子視窗與控制項
    if (g_mainWindow) {
        RedrawWindow(g_mainWindow, nullptr, nullptr, RDW_INVALIDATE | RDW_UPDATENOW | RDW_ERASE | RDW_ALLCHILDREN);
    }
}

LRESULT CALLBACK MainWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    switch (msg) {
    case WM_CREATE: {
        LOGFONTW lf{};
        GetObjectW(GetStockObject(DEFAULT_GUI_FONT), sizeof(lf), &lf);
        lf.lfHeight = -22;
        lf.lfWeight = FW_BOLD;
        g_titleFont = CreateFontIndirectW(&lf);

        HWND hLabel = CreateWindowExW(0, L"STATIC", L"", WS_CHILD | WS_VISIBLE, 355, 8, 55, 20, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kLangLabelId)), nullptr, nullptr);
        SetControlFont(hLabel);

        HWND hCombo = CreateWindowExW(0, WC_COMBOBOXW, L"",
            WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | WS_TABSTOP,
            410, 5, 120, 100, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kLangComboId)), nullptr, nullptr);
        SetControlFont(hCombo);
        SendMessageW(hCombo, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>(L"English"));
        SendMessageW(hCombo, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>(L"繁體中文"));
        SendMessageW(hCombo, CB_SETCURSEL, (g_appLanguage == AppLanguage::TraditionalChinese) ? 1 : 0, 0);

        g_tabCtrl = CreateWindowExW(0, WC_TABCONTROLW, L"", WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS, 5, 35, 530, 410, hwnd, reinterpret_cast<HMENU>(static_cast<INT_PTR>(kTabControlId)), nullptr, nullptr);
        SetControlFont(g_tabCtrl);

        TCITEMW tie{};
        tie.mask = TCIF_TEXT;
        
        tie.pszText = const_cast<LPWSTR>(UiText(L"Printer Deployment", L"印表機部署"));
        TabCtrl_InsertItem(g_tabCtrl, 0, &tie);

        tie.pszText = const_cast<LPWSTR>(UiText(L"About", L"關於"));
        TabCtrl_InsertItem(g_tabCtrl, 1, &tie);

        static HINSTANCE instance = GetModuleHandleW(nullptr);
        WNDCLASSEXW wcx{};
        wcx.cbSize = sizeof(wcx);
        wcx.lpfnWndProc = AboutPageProc;
        wcx.hInstance = instance;
        wcx.hCursor = LoadCursorW(nullptr, IDC_ARROW);
        wcx.hbrBackground = GetSysColorBrush(COLOR_BTNFACE);
        wcx.lpszClassName = L"PrtEasySetupAboutPage";
        RegisterClassExW(&wcx);

        wcx.lpfnWndProc = DeployPageProc;
        wcx.lpszClassName = L"PrtEasySetupDeployPage";
        RegisterClassExW(&wcx);

        g_aboutPage = CreateWindowExW(0, L"PrtEasySetupAboutPage", L"", WS_CHILD, 15, 65, 510, 370, hwnd, nullptr, instance, nullptr);
        g_deployPage = CreateWindowExW(0, L"PrtEasySetupDeployPage", L"", WS_CHILD | WS_VISIBLE, 15, 65, 510, 370, hwnd, nullptr, instance, nullptr);

        TabCtrl_SetCurSel(g_tabCtrl, 0);
        ShowWindow(g_deployPage, SW_SHOW);
        ShowWindow(g_aboutPage, SW_HIDE);

        RefreshMainTabUI();
        return 0;
    }
    case WM_COMMAND: {
        if (LOWORD(wParam) == kLangComboId && HIWORD(wParam) == CBN_SELCHANGE) {
            HWND hCombo = reinterpret_cast<HWND>(lParam);
            int sel = static_cast<int>(SendMessageW(hCombo, CB_GETCURSEL, 0, 0));
            if (sel == 1) {
                SwitchLanguage(AppLanguage::TraditionalChinese);
            } else {
                SwitchLanguage(AppLanguage::English);
            }
        }
        return 0;
    }
    case WM_NOTIFY: {
        LPNMHDR hdr = reinterpret_cast<LPNMHDR>(lParam);
        if (hdr->hwndFrom == g_tabCtrl && hdr->code == TCN_SELCHANGE) {
            int sel = TabCtrl_GetCurSel(g_tabCtrl);
            if (sel == 0) {
                ShowWindow(g_deployPage, SW_SHOW);
                ShowWindow(g_aboutPage, SW_HIDE);
                SendMessageW(g_deployPage, WM_UPDATE_DEPLOY_UI, 0, 0);
            } else {
                ShowWindow(g_aboutPage, SW_SHOW);
                ShowWindow(g_deployPage, SW_HIDE);
                RefreshAboutUI();
            }
        }
        return 0;
    }
    case WM_DESTROY: {
        if (g_titleFont) {
            DeleteObject(g_titleFont);
            g_titleFont = nullptr;
        }
        if (g_linkFont) {
            DeleteObject(g_linkFont);
            g_linkFont = nullptr;
        }
        PostQuitMessage(0);
        return 0;
    }
    case WM_CTLCOLORSTATIC: {
        HDC hdc = reinterpret_cast<HDC>(wParam);
        SetBkMode(hdc, TRANSPARENT);
        return reinterpret_cast<LRESULT>(GetSysColorBrush(COLOR_BTNFACE));
    }
    default:
        break;
    }
    return DefWindowProcW(hwnd, msg, wParam, lParam);
}

int WINAPI wWinMain(HINSTANCE instance, HINSTANCE, PWSTR, int cmdShow) {
    INITCOMMONCONTROLSEX icc{};
    icc.dwSize = sizeof(icc);
    icc.dwICC = ICC_TAB_CLASSES | ICC_LINK_CLASS | ICC_PROGRESS_CLASS;
    InitCommonControlsEx(&icc);

    wchar_t modulePath[MAX_PATH] = {};
    GetModuleFileNameW(nullptr, modulePath, MAX_PATH);
    g_baseDir = fs::path(modulePath).parent_path();
    g_logPath = g_baseDir / L"PrtEasySetup.log";
    
    ApplyLanguageSetting(L"auto");
    const fs::path iniPath = g_baseDir / L"ip.ini";
    if (fs::exists(iniPath)) {
        ApplyLanguageSetting(ReadIniLanguageSetting(iniPath));
    }

    Log(L"============================================================");
    Log(L"PrtEasySetup started.");
    Log(L"BaseDir: " + g_baseDir.wstring());
    Log(L"Arch: " + GetArchitectureLabel());

    if (!IsRunningAsAdmin()) {
        Log(L"Not elevated. Relaunch requested.");
        if (RelaunchAsAdmin()) {
            return 0;
        }
        ShowErrorWithLog(
            UiText(L"Error", L"錯誤"),
            UiText(L"Administrator permission is required to install printers.",
                   L"安裝印表機需要系統管理員權限。"));
        return 1;
    }

    WNDCLASSEXW wcx{};
    wcx.cbSize = sizeof(wcx);
    wcx.lpfnWndProc = MainWindowProc;
    wcx.hInstance = instance;
    wcx.hIcon = GetAppIconLarge();
    wcx.hIconSm = GetAppIconSmall();
    wcx.hCursor = LoadCursorW(nullptr, IDC_ARROW);
    wcx.hbrBackground = GetSysColorBrush(COLOR_BTNFACE);
    wcx.lpszClassName = L"PrtEasySetupMainWindowClass";
    RegisterClassExW(&wcx);

    int winWidth = 545;
    int winHeight = 490;
    
    RECT wr = { 0, 0, winWidth, winHeight };
    AdjustWindowRectEx(&wr, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX, FALSE, 0);
    int realWidth = wr.right - wr.left;
    int realHeight = wr.bottom - wr.top;

    HWND hwnd = CreateWindowExW(
        0, L"PrtEasySetupMainWindowClass",
        L"PrtEasySetup",
        WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
        CW_USEDEFAULT, CW_USEDEFAULT, realWidth, realHeight,
        nullptr, nullptr, instance, nullptr);

    if (!hwnd) {
        Log(L"Failed to create main window.");
        return 1;
    }

    g_mainWindow = hwnd;
    CenterWindowOnOwner(hwnd, nullptr, realWidth, realHeight);
    
    ShowWindow(hwnd, cmdShow);
    UpdateWindow(hwnd);

    MSG msg{};
    while (GetMessageW(&msg, nullptr, 0, 0) > 0) {
        if (!IsDialogMessageW(hwnd, &msg)) {
            TranslateMessage(&msg);
            DispatchMessageW(&msg);
        }
    }

    Log(L"PrtEasySetup exiting.");
    return 0;
}