widget.cpp

#include "widget.h"
#include "screencapture.h"
#include "debug_helper.h"
#include <QMessageBox>
#include <QScrollBar>
#include <QtConcurrent>
#include <QFutureWatcher>
#include <QDebug>
#include <chrono>
#include <QClipboard>
#include <QApplication>
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <QTextStream>
#include <QDateTime>
#include <QTextEdit>
#include <QTextDocument>
#include <QTextCursor>
#include <QTextCharFormat>
#include <tesseract/baseapi.h>
#include <leptonica/allheaders.h>

// Windows头文件（用于内存检查）
#ifdef Q_OS_WIN
#include <Windows.h>
#endif

// llama 头文件
#include "llama-cpp.h"
#include "ggml-backend.h"

// 模型路径将从配置文件中读取

Widget::Widget(QWidget *parent)
    : QWidget(parent), isTranslating(false), shouldStopTranslation(false), isStayOnTop(false), currentWatcher(nullptr),
      sourceLanguage("英语"), targetLanguage("中文")
{
    DebugHelper::log("Widget构造函数开始");
    
    // 设置窗口标题
    setWindowTitle("英译汉");
    DebugHelper::log("窗口标题设置完成");

    // 亲自然设计 - 全局样式
    setStyleSheet(R"(
        /* 全局字体 */
        * {
            font-family: "Microsoft YaHei", "Segoe UI", sans-serif;
        }
        
        /* 窗口背景 - 柔和渐变 + 微噪点 */
        QWidget {
            background-color: #f7f6f2;
        }
        
        /* 输入框 - 纸质感 + 叶脉纹理感 */
        QTextEdit {
            background-color: #faf9f6;
            border: 1px solid #d4d0c8;
            border-radius: 12px;
            padding: 8px;
            font-size: 14px;
            color: #3d3d3d;
            selection-background-color: #b8d4b8;
        }
        QTextEdit:focus {
            border: 2px solid #7a9e7a;
            background-color: #ffffff;
        }
        QTextEdit[readOnly="true"] {
            background-color: #f0efe9;
            color: #5a5a5a;
        }
        
        /* 按钮基础样式 */
        QPushButton {
            background-color: #7a9e7a;
            color: white;
            border: none;
            border-radius: 8px;
            padding: 6px 20px;
            font-size: 14px;
            font-weight: 500;
        }
        QPushButton:hover {
            background-color: #8fb08f;
        }
        QPushButton:pressed {
            background-color: #6a8e6a;
            padding-top: 11px;
            padding-bottom: 9px;
        }
        
        /* 交换按钮 */
        QPushButton#swapLangButton {
            background-color: transparent;
            border: 2px solid #a8c4a8;
            border-radius: 8px;
            padding: 4px;
        }
        QPushButton#swapLangButton:hover {
            background-color: #e8f0e8;
            border-color: #7a9e7a;
        }
        QPushButton#swapLangButton:pressed {
            background-color: #d0e0d0;
        }
        
        /* 置顶按钮 */
        QPushButton#stayOnTopButton {
            background-color: transparent;
            border: none;
            border-radius: 6px;
            padding: 4px;
        }
        QPushButton#stayOnTopButton:hover {
            background-color: #e8f0e8;
        }
        
        /* 截图按钮 */
        QPushButton#screenshotButton {
            background-color: transparent;
            border: none;
            border-radius: 6px;
            padding: 4px;
        }
        QPushButton#screenshotButton:hover {
            background-color: #e8f0e8;
        }
        
        /* 设置按钮 */
        QPushButton#settingsButton {
            background-color: transparent;
            border: none;
            border-radius: 6px;
            padding: 4px;
        }
        QPushButton#settingsButton:hover {
            background-color: #e8f0e8;
        }
        
        /* 清除按钮 */
        QPushButton#clearInputButton {
            background-color: transparent;
            color: #9ca89c;
            border: none;
            font-size: 18px;
            padding: 4px 8px;
            border-radius: 4px;
        }
        QPushButton#clearInputButton:hover {
            color: #d47474;
            background-color: #fff0f0;
        }
        
        /* 语言标签 */
        QLabel {
            color: #4a5a4a;
            font-size: 14px;
            font-weight: 500;
        }
        
        /* 分组框 */
        QGroupBox {
            color: #4a5a4a;
            font-weight: 500;
            border: 1px solid #d4d0c8;
            border-radius: 8px;
            margin-top: 10px;
            padding-top: 10px;
        }
        QGroupBox::title {
            color: #4a5a4a;
        }
        
        /* 复选框 */
        QCheckBox {
            color: #4a5a4a;
        }
        QCheckBox::indicator {
            width: 18px;
            height: 18px;
        }
        QCheckBox::indicator:unchecked {
            border: 2px solid #a8c4a8;
            border-radius: 3px;
            background-color: #faf9f6;
        }
        QCheckBox::indicator:checked {
            background-color: #7a9e7a;
            border: 2px solid #7a9e7a;
            border-radius: 3px;
        }
        
        /* 组合框 */
        QComboBox {
            background-color: #faf9f6;
            color: #3d3d3d;
            border: 1px solid #d4d0c8;
            border-radius: 6px;
            padding: 6px 12px;
        }
        QComboBox:hover {
            border: 2px solid #7a9e7a;
        }
        QComboBox::drop-down {
            border: none;
        }
        QComboBox::down-arrow {
            image: none;
            border-left: 5px solid transparent;
            border-right: 5px solid transparent;
            border-top: 6px solid #7a9e7a;
            margin-right: 8px;
        }
        
        /* 数字选择框 */
        QSpinBox {
            background-color: #faf9f6;
            color: #3d3d3d;
            border: 1px solid #d4d0c8;
            border-radius: 6px;
            padding: 6px;
        }
        QSpinBox:hover {
            border: 2px solid #7a9e7a;
        }
        
        /* 标签页 */
        QTabWidget::pane {
            border: 1px solid #d4d0c8;
            border-radius: 8px;
            background-color: #faf9f6;
        }
        QTabBar::tab {
            background-color: #e8f0e8;
            color: #4a5a4a;
            padding: 8px 16px;
            border-top-left-radius: 6px;
            border-top-right-radius: 6px;
        }
        QTabBar::tab:selected {
            background-color: #faf9f6;
            color: #3d5a3d;
            font-weight: 500;
        }
        
        /* 快捷键编辑框 */
        QKeySequenceEdit {
            background-color: #faf9f6;
            color: #3d3d3d;
            border: 1px solid #d4d0c8;
            border-radius: 6px;
            padding: 6px;
        }
        QKeySequenceEdit:hover {
            border: 2px solid #7a9e7a;
        }
        QKeySequenceEdit:focus {
            border: 2px solid #7a9e7a;
            background-color: #ffffff;
        }
        
        /* 单行文本框 */
        QLineEdit {
            background-color: #faf9f6;
            color: #3d3d3d;
            border: 1px solid #d4d0c8;
            border-radius: 6px;
            padding: 6px 10px;
        }
        QLineEdit:hover {
            border: 2px solid #7a9e7a;
        }
        QLineEdit:focus {
            border: 2px solid #7a9e7a;
            background-color: #ffffff;
        }
        
        /* 滚动条美化 */
        QScrollBar:vertical {
            background-color: transparent;
            width: 8px;
            border: none;
            margin: 0px;
        }
        QScrollBar::handle:vertical {
            background-color: #c8d8c8;
            border-radius: 4px;
            min-height: 30px;
            margin: 0px;
        }
        QScrollBar::handle:vertical:hover {
            background-color: #7a9e7a;
        }
        QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical {
            height: 0px;
        }
        QScrollBar::add-page:vertical, QScrollBar::sub-page:vertical {
            background: none;
        }
        QScrollBar:horizontal {
            background-color: transparent;
            height: 8px;
            border: none;
            margin: 0px;
        }
        QScrollBar::handle:horizontal {
            background-color: #c8d8c8;
            border-radius: 4px;
            min-width: 30px;
            margin: 0px;
        }
        QScrollBar::handle:horizontal:hover {
            background-color: #7a9e7a;
        }
        QScrollBar::add-line:horizontal, QScrollBar::sub-line:horizontal {
            width: 0px;
        }
        QScrollBar::add-page:horizontal, QScrollBar::sub-page:horizontal {
            background: none;
        }
    )");

    // 输入输出区域
    inputTextEdit = new QTextEdit(this);
    inputTextEdit->setPlaceholderText("请输入要翻译的文本...");
    inputTextEdit->setMinimumHeight(150);
    inputTextEdit->installEventFilter(this);

    outputTextEdit = new QTextEdit(this);
    outputTextEdit->setReadOnly(true);
    outputTextEdit->setMinimumHeight(150);

    

    // 功能按钮
    sendButton = new QPushButton("翻译", this);
    copyButton = new QPushButton("复制", this);
    clearInputButton = new QPushButton("×", this);
    clearInputButton->setObjectName("clearInputButton");
    clearInputButton->setFixedWidth(30);
    clearInputButton->setToolTip("清空");
    
    // 置顶按钮使用图标
    stayOnTopButton = new QPushButton(this);
    stayOnTopButton->setObjectName("stayOnTopButton");
    stayOnTopButton->setFixedSize(30, 30);
    stayOnTopButton->setIcon(QIcon(":/resource_icon/nail_copy.svg"));
    stayOnTopButton->setIconSize(QSize(20, 20));
    stayOnTopButton->setToolTip("置顶");
    
    // 截图按钮使用图标
    screenshotButton = new QPushButton(this);
    screenshotButton->setObjectName("screenshotButton");
    screenshotButton->setFixedSize(30, 30);
    screenshotButton->setIcon(QIcon(":/resource_icon/screenshot-line.svg"));
    screenshotButton->setIconSize(QSize(26, 26));
    screenshotButton->setToolTip("截图OCR");
    
    settingsButton = new QPushButton(this);
    settingsButton->setObjectName("settingsButton");
    settingsButton->setFixedSize(40, 40);
    settingsButton->setIcon(QIcon(":/resource_icon/setting.svg"));
    settingsButton->setIconSize(QSize(36, 36));
    settingsButton->setToolTip("设置");

    // 语言标签和交换按钮
    sourceLangLabel = new QLabel("英语", this);
    targetLangLabel = new QLabel("中文", this);
    swapLangButton = new QPushButton(this);
    swapLangButton->setObjectName("swapLangButton");
    swapLangButton->setFixedSize(30, 30);
    swapLangButton->setIcon(QIcon(":/resource_icon/exchange.svg"));
    swapLangButton->setIconSize(QSize(20, 20));
    swapLangButton->setToolTip("交换语言");

    // 输入定时器，用于实现实时翻译
    inputTimer = new QTimer(this);
    inputTimer->setSingleShot(true);
    inputTimer->setInterval(ConfigManager::instance()->getAutoTranslateDelay()); // 从配置中读取延迟时间

    // 主布局
    QVBoxLayout *mainLayout = new QVBoxLayout(this);
    mainLayout->setContentsMargins(13, 13, 13, 13);
    mainLayout->setSpacing(15);

    // 顶部输入区域
    QVBoxLayout *inputLayout = new QVBoxLayout();

    // 输入区标题和按钮
    QHBoxLayout *inputHeaderLayout = new QHBoxLayout();
    inputHeaderLayout->addWidget(new QLabel("原文", this));
    inputHeaderLayout->addStretch();
    inputHeaderLayout->addWidget(stayOnTopButton);
    inputHeaderLayout->addWidget(screenshotButton);
    inputHeaderLayout->addWidget(settingsButton);
    inputHeaderLayout->addWidget(clearInputButton);

    inputLayout->addLayout(inputHeaderLayout);
    inputLayout->addWidget(inputTextEdit);

    mainLayout->addLayout(inputLayout);

    // 语言选择栏（源语言 -> 目标语言）
    QHBoxLayout *langSelectLayout = new QHBoxLayout();
    langSelectLayout->addStretch();
    langSelectLayout->addWidget(sourceLangLabel);
    langSelectLayout->addWidget(swapLangButton);
    langSelectLayout->addWidget(targetLangLabel);
    langSelectLayout->addStretch();
    mainLayout->addLayout(langSelectLayout);

    // 输出区域
    QVBoxLayout *outputLayout = new QVBoxLayout();
    outputLayout->addWidget(outputTextEdit);
    mainLayout->addLayout(outputLayout);

    // 功能按钮栏
    QHBoxLayout *buttonLayout = new QHBoxLayout();
    buttonLayout->addWidget(sendButton);
    buttonLayout->addWidget(copyButton);
    mainLayout->addLayout(buttonLayout);

    setLayout(mainLayout);

    // 设置窗口大小
    QSize defaultSize = ConfigManager::instance()->getDefaultWindowSize();
    resize(defaultSize);

    // 信号连接
    connect(sendButton, &QPushButton::clicked, this, &Widget::onSendClicked);
    connect(inputTextEdit, &QTextEdit::textChanged, this, &Widget::onInputTextChanged);
    connect(copyButton, &QPushButton::clicked, this, &Widget::onCopyResult);
    connect(clearInputButton, &QPushButton::clicked, inputTextEdit, &QTextEdit::clear);
    connect(stayOnTopButton, &QPushButton::clicked, this, &Widget::onStayOnTopClicked);
    connect(screenshotButton, &QPushButton::clicked, this, &Widget::startScreenCapture);
    connect(settingsButton, &QPushButton::clicked, this, &Widget::onSettingsButtonClicked);
    connect(swapLangButton, &QPushButton::clicked, this, &Widget::swapLanguages);
    connect(inputTimer, &QTimer::timeout, this, &Widget::onSendClicked);

    DebugHelper::log("初始化OCR...");
    // 初始化 OCR
    initTesseract();
    DebugHelper::log("OCR初始化完成");

    // 注册全局热键
    DebugHelper::log("注册热键...");
    ConfigManager *config = ConfigManager::instance();
    if (config->getHotkeyEnabled()) {
        if (!registerGlobalHotkey()) {
            qDebug() << "无法注册全局热键，将使用普通快捷键作为备选";
            DebugHelper::log("全局热键注册失败，使用普通快捷键");
            // 如果全局热键注册失败，使用普通快捷键作为备选
            ocrShortcut = new QShortcut(QKeySequence(config->getHotkey()), this);
            connect(ocrShortcut, &QShortcut::activated, this, &Widget::onOCRShortcutTriggered);
        } else {
            qDebug() << "全局热键注册成功（" << config->getHotkey() << "）";
            DebugHelper::log("全局热键注册成功");
            ocrShortcut = nullptr; // 不需要普通快捷键
        }
    } else {
        qDebug() << "快捷键已禁用";
        DebugHelper::log("快捷键已禁用");
        ocrShortcut = nullptr;
    }

    // llama 初始化
    DebugHelper::log("初始化llama后端...");
    ggml_backend_load_all();
    DebugHelper::log("llama后端初始化完成");

    llama_model_params mparams = llama_model_default_params();
    QString modelPath = ConfigManager::instance()->getModelPath();
    
    // 如果是相对路径，转换为相对于应用程序目录的绝对路径
    QFileInfo modelFileInfo(modelPath);
    if (modelFileInfo.isRelative()) {
        QString appDir = QCoreApplication::applicationDirPath();
        modelPath = QDir(appDir).absoluteFilePath(modelPath);
        qDebug() << "相对路径转换为绝对路径:" << modelPath;
    }
    
    // 检查模型文件是否存在
    QFile modelFile(modelPath);
    if (!modelFile.exists()) {
        QMessageBox::warning(this, "模型文件不存在", 
            "未找到模型文件，请前往以下地址下载模型文件：\n\n"
            "https://modelscope.cn/models/Tencent-Hunyuan/HY-MT1.5-1.8B-GGUF/files\n\n"
            "请下载文件：HY-MT1.5-1.8B-Q8_0.gguf\n\n"
            "下载完成后，请点击 设置 -> 模型设置 选择您的模型文件路径。");
        // 不加载模型，但保持窗口可用，允许用户进入设置界面
        this->model = nullptr;
    } else {
        // 检查可用内存
        MEMORYSTATUSEX memStatus;
        memStatus.dwLength = sizeof(memStatus);
        GlobalMemoryStatusEx(&memStatus);
        
        DWORDLONG totalMem = memStatus.ullTotalPhys / (1024 * 1024); // MB
        DWORDLONG availMem = memStatus.ullAvailPhys / (1024 * 1024); // MB
        
        qDebug() << "系统总内存:" << totalMem << "MB";
        qDebug() << "可用内存:" << availMem << "MB";
        qDebug() << "正在加载模型:" << modelPath;
        qDebug() << "模型文件大小:" << modelFile.size() << "bytes";
        
        this->model = llama_model_load_from_file(modelPath.toUtf8().constData(), mparams);
        if (model == nullptr) {
            qDebug() << __func__ << ": error: unable to load model";
            QMessageBox::critical(this, "模型加载失败", 
                QString("模型文件加载失败，可能原因：\n\n"
                        "1. CPU不支持AVX2指令集\n"
                        "2. 模型文件损坏\n\n"
                        "您可以前往以下地址重新下载：\n\n"
                        "https://modelscope.cn/models/Tencent-Hunyuan/HY-MT1.5-1.8B-GGUF/files\n\n"
                        "请下载文件：HY-MT1.5-1.8B-Q8_0.gguf"));
            // 不加载模型，但保持窗口可用
            this->model = nullptr;
        } else {
            qDebug() << "模型加载成功";
        }
    }

    // 流式输出信号连接
    connect(this, &Widget::streamTokenReady, this, [this, config](const QString &token){
        outputTextEdit->insertPlainText(token);
        if (config->getFollowTranslation()) {
            outputTextEdit->moveCursor(QTextCursor::End);
            outputTextEdit->verticalScrollBar()->setValue(outputTextEdit->verticalScrollBar()->maximum());
        }
    });
}

Widget::~Widget() {
    delete inputTimer;
    if (ocrShortcut) {
        delete ocrShortcut;
    }
    unregisterGlobalHotkey(); // 注销全局热键
    if (model != nullptr) {
        llama_model_free(model);
    }
}

bool Widget::eventFilter(QObject *obj, QEvent *event) {
    if (obj == inputTextEdit) {
        if (event->type() == QEvent::KeyPress) {
            QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
            if (keyEvent->modifiers() == Qt::ControlModifier && keyEvent->key() == Qt::Key_V) {
                QClipboard *clipboard = QApplication::clipboard();
                QString text = clipboard->text();
                if (!text.isEmpty()) {
                    event->accept();
                    QTextCursor cursor = inputTextEdit->textCursor();
                    cursor.insertText(text);
                    return true;
                }
            }
        }
    }
    return QWidget::eventFilter(obj, event);
}

// 从资源文件提取traineddata文件
bool Widget::extractResourceFiles() {
    QString appDir = QCoreApplication::applicationDirPath();
    QString tessdataDir = appDir + "/tessdata";
    
    QDir dir;
    if (!dir.exists(tessdataDir)) {
        dir.mkpath(tessdataDir);
    }
    
    QStringList filesToExtract = {
        ":/tessdata/chi_sim.traineddata",
        ":/tessdata/eng.traineddata"
    };
    
    for (const QString &resourcePath : filesToExtract) {
        QString fileName = QFileInfo(resourcePath).fileName();
        QString targetPath = tessdataDir + "/" + fileName;
        
        QFile resourceFile(resourcePath);
        if (!resourceFile.open(QIODevice::ReadOnly)) {
            qDebug() << "无法打开资源文件:" << resourcePath;
            return false;
        }
        
        QFile targetFile(targetPath);
        if (targetFile.exists()) {
            resourceFile.close();
            continue;
        }
        
        if (!targetFile.open(QIODevice::WriteOnly)) {
            qDebug() << "无法创建目标文件:" << targetPath;
            resourceFile.close();
            return false;
        }
        
        targetFile.write(resourceFile.readAll());
        targetFile.close();
        resourceFile.close();
        
        qDebug() << "提取资源文件:" << fileName << "到:" << targetPath;
    }
    
    return true;
}

// 初始化 Tesseract
void Widget::initTesseract() {
    // 先从资源文件提取traineddata文件
    if (!extractResourceFiles()) {
        qDebug() << "提取资源文件失败";
        return;
    }
    
    // 设置 Tesseract 数据目录环境变量
    QString appDir = QCoreApplication::applicationDirPath();
    QString tessdataPath = appDir + "/tessdata";
    qputenv("TESSDATA_PREFIX", tessdataPath.toUtf8());

    qDebug() << "Tesseract 初始化完成，数据目录:" << tessdataPath;
}

void Widget::onInputTextChanged() {
    qDebug() << "onInputTextChanged - sourceLanguage:" << sourceLanguage << "targetLanguage:" << targetLanguage;
    
    inputTimer->start();
}

void Widget::onSendClicked() {
    qDebug() << "onSendClicked - sourceLanguage:" << sourceLanguage << "targetLanguage:" << targetLanguage;
    
    // 如果正在翻译，点击按钮将停止翻译
    if (isTranslating) {
        onStopTranslation();
        return;
    }

    QString inputText = inputTextEdit->toPlainText().trimmed();
    if (inputText.isEmpty()) return;

    isTranslating = true;
    shouldStopTranslation = false;
    sendButton->setText("停止");

    // 清空输出区域
    outputTextEdit->clear();

    // 使用成员变量中的语言设置
    QString sourceLang = sourceLanguage;
    QString targetLang = targetLanguage;

    // 打印源语言和目标语言
    qDebug() << "源语言:" << sourceLang;
    qDebug() << "目标语言:" << targetLang;

    // 生成翻译提示词
    QString prompt = generateTranslationPrompt(inputText, sourceLang, targetLang);

    // llama 推理放到后台线程（流式输出）
    QFutureWatcher<void> *watcher = new QFutureWatcher<void>(this);
    connect(watcher, &QFutureWatcher<void>::finished, this, [this, watcher]() {
        if (!shouldStopTranslation) {
            isTranslating = false;
            sendButton->setText("翻译");
        }
        watcher->deleteLater();
    });
    QFuture<void> future = QtConcurrent::run([this, prompt]() {
        streamQueryLlama(prompt);
    });
    watcher->setFuture(future);
}

void Widget::onCopyResult() {
    // 复制翻译结果到剪贴板
    QString result = outputTextEdit->toPlainText();
    if (!result.isEmpty()) {
        QClipboard *clipboard = QApplication::clipboard();
        clipboard->setText(result);
        QMessageBox::information(this, "提示", "翻译结果已复制到剪贴板");
    }
}



void Widget::onStopTranslation() {
    // 设置停止标志
    shouldStopTranslation = true;

    // 恢复按钮状态
    isTranslating = false;
    sendButton->setText("翻译");
}

// 交换语言
void Widget::swapLanguages() {
    qDebug() << "交换前 - sourceLanguage:" << sourceLanguage << "targetLanguage:" << targetLanguage;
    
    QString temp = sourceLanguage;
    sourceLanguage = targetLanguage;
    targetLanguage = temp;
    
    sourceLangLabel->setText(sourceLanguage);
    targetLangLabel->setText(targetLanguage);
    
    qDebug() << "交换后 - sourceLanguage:" << sourceLanguage << "targetLanguage:" << targetLanguage;
    
    QString inputText = inputTextEdit->toPlainText();
    QString outputText = outputTextEdit->toPlainText();
    inputTextEdit->setPlainText(outputText);
    outputTextEdit->setPlainText(inputText);
    
    if (!inputTextEdit->toPlainText().isEmpty()) {
        onSendClicked();
    }
}

// OCR 快捷键触发事件
void Widget::onOCRShortcutTriggered() {
    qDebug() << "OCR 快捷键触发";
    startScreenCapture();
}

// 开始屏幕截图
void Widget::startScreenCapture() {
    // 先隐藏主窗口，防止遮挡截屏
    hide();
    
    // 延迟一点时间再显示截屏界面，确保主窗口已经隐藏
    QTimer::singleShot(100, this, [this]() {
        // 创建屏幕截图窗口
        ScreenCapture *capture = new ScreenCapture(this);
        
        // 连接信号 - 截屏完成后调用OCR处理，完成后显示主窗口
        connect(capture, &ScreenCapture::captureCompleted, this, [this](const QPixmap &screenshot) {
            onScreenshotCompleted(screenshot);
            show();
            activateWindow();
        });
        connect(capture, &ScreenCapture::captureCanceled, this, [this]() {
            show();
            activateWindow();
        });
        connect(capture, &ScreenCapture::captureCompleted, capture, &ScreenCapture::deleteLater);
        connect(capture, &ScreenCapture::captureCanceled, capture, &ScreenCapture::deleteLater);
        
        // 显示截图窗口
        capture->show();
    });
}

// 生成翻译提示词
QString Widget::generateTranslationPrompt(const QString &sourceText, const QString &sourceLang, const QString &targetLang) {
    qDebug() << "generateTranslationPrompt - sourceLang length:" << sourceLang.length();
    qDebug() << "generateTranslationPrompt - sourceLang toUtf8:" << sourceLang.toUtf8().toHex();
    qDebug() << "generateTranslationPrompt - targetLang length:" << targetLang.length();
    
    QString prompt;
    if (sourceLang == "中文") {
        qDebug() << "条件1满足: sourceLang == 中文";
        prompt = "Translate the following Chinese text into English, without additional explanation.\n\n" + sourceText;
    } else if (sourceLang == "英语") {
        qDebug() << "条件2满足: sourceLang == 英语";
        prompt = "Translate the following English text into Chinese, without additional explanation.\n\n" + sourceText;
    } else {
        qDebug() << "条件都不满足，使用默认";
        prompt = "Translate the following text, without additional explanation.\n\n" + sourceText;
    }
    
    qDebug() << "生成翻译提示词 - 源语言:" << sourceLang << "目标语言:" << targetLang;
    qDebug() << "提示词内容:" << prompt;
    return prompt;
}

// 语言代码映射
QString Widget::getLanguageCode(const QString &languageName) {
    // 语言名称到代码的映射
    if (languageName == "中文") return "zh";
    if (languageName == "英语") return "en";
    if (languageName == "日语") return "ja";
    if (languageName == "韩语") return "ko";
    if (languageName == "法语") return "fr";
    if (languageName == "西班牙语") return "es";
    if (languageName == "德语") return "de";
    if (languageName == "俄语") return "ru";
    return "en";
}

// 屏幕截图完成事件
void Widget::onScreenshotCompleted(const QPixmap &screenshot) {
    qDebug() << "截图完成，开始 OCR 处理";

    // 在后台线程中执行 OCR
    QtConcurrent::run([this, screenshot]() {
        QString extractedText = performOCR(screenshot);

        // 回到主线程处理结果
        QMetaObject::invokeMethod(this, [this, extractedText]() {
            if (!extractedText.isEmpty()) {
                // 将识别的文本填入输入框
                inputTextEdit->setPlainText(extractedText);

                // 触发自动翻译
                inputTimer->start();

                qDebug() << "OCR 完成，文本已自动填入输入框并开始翻译";
            } else {
                qDebug() << "OCR 失败，未能从截图中识别出文本";
            }
        }, Qt::QueuedConnection);
    });
}

// OCR 文本提取
QString Widget::performOCR(const QPixmap &image) {
    // 根据源语言选择 OCR 语言
    QString ocrLang;
    if (sourceLanguage == "中文") {
        ocrLang = "chi_sim";
    } else {
        ocrLang = "eng";
    }

    qDebug() << "使用 OCR 语言:" << ocrLang;

    // 将 QPixmap 转换为 QImage
    QImage qImage = image.toImage().convertToFormat(QImage::Format_RGB32);

    // 创建原始彩色图像的 Pix
    Pix *originalPix = pixCreate(qImage.width(), qImage.height(), 32);
    for (int y = 0; y < qImage.height(); y++) {
        for (int x = 0; x < qImage.width(); x++) {
            QRgb rgb = qImage.pixel(x, y);
            l_uint32 pixel = (qRed(rgb) << 16) | (qGreen(rgb) << 8) | qBlue(rgb);
            pixSetPixel(originalPix, x, y, pixel);
        }
    }

    // 测试函数：使用指定图像进行 OCR 并返回置信度
    auto testOCRConfidence = [&](Pix *testPix, const QString &testName) -> int {
        tesseract::TessBaseAPI *testApi = new tesseract::TessBaseAPI();
        QString appDir = QCoreApplication::applicationDirPath();
        QString tessdataPath = appDir + "/tessdata";
        if (testApi->Init(tessdataPath.toUtf8().constData(), ocrLang.toUtf8().constData())) {
            qDebug() << testName << "Tesseract 初始化失败";
            delete testApi;
            return 0;
        }

        testApi->SetImage(testPix);
        char *testText = testApi->GetUTF8Text();
        int confidence = testApi->MeanTextConf();

        qDebug() << testName << "置信度:" << confidence;

        delete[] testText;
        testApi->End();
        delete testApi;

        return confidence;
    };

    // 1. 测试原图（彩色）的置信度
    qDebug() << "=== OCR 置信度测试 ===";
    int originalConfidence = testOCRConfidence(originalPix, "原图");

    // 2. 测试三通道分别转灰度图的置信度
    Pix *redChannelPix = nullptr;
    Pix *greenChannelPix = nullptr;
    Pix *blueChannelPix = nullptr;
    int redConfidence = 0;
    int greenConfidence = 0;
    int blueConfidence = 0;

    // 辅助函数:提取指定颜色通道并创建 Pix 图像
    auto extractChannel = [&](std::function<l_uint8(QRgb)> channelFunc) -> Pix* {
        Pix *channelPix = pixCreate(qImage.width(), qImage.height(), 8);
        
        // 使用 bits() 直接访问内存,提高性能
        const uchar *imageBits = qImage.constBits();
        int bytesPerLine = qImage.bytesPerLine();
        
        for (int y = 0; y < qImage.height(); y++) {
            const QRgb *scanLine = reinterpret_cast<const QRgb*>(imageBits + y * bytesPerLine);
            for (int x = 0; x < qImage.width(); x++) {
                l_uint8 channelValue = channelFunc(scanLine[x]);
                pixSetPixel(channelPix, x, y, channelValue);
            }
        }
        
        return channelPix;
    };

    // 提取三个颜色通道
    redChannelPix = extractChannel([](QRgb rgb) { return qRed(rgb); });
    redConfidence = testOCRConfidence(redChannelPix, "红色通道");
    
    greenChannelPix = extractChannel([](QRgb rgb) { return qGreen(rgb); });
    greenConfidence = testOCRConfidence(greenChannelPix, "绿色通道");
    
    blueChannelPix = extractChannel([](QRgb rgb) { return qBlue(rgb); });
    blueConfidence = testOCRConfidence(blueChannelPix, "蓝色通道");

    // 3. 选择置信度最高的图像进行最终识别
    Pix *bestPix = originalPix;
    int bestConfidence = originalConfidence;
    QString bestImageName = "原图";

    if (redConfidence > bestConfidence) {
        bestPix = redChannelPix;
        bestConfidence = redConfidence;
        bestImageName = "红色通道";
    }
    if (greenConfidence > bestConfidence) {
        // 如果之前的最佳图像不是原图，需要释放
        if (bestPix != originalPix) {
            pixDestroy(&bestPix);
        }
        bestPix = greenChannelPix;
        bestConfidence = greenConfidence;
        bestImageName = "绿色通道";
    }
    if (blueConfidence > bestConfidence) {
        // 如果之前的最佳图像不是原图，需要释放
        if (bestPix != originalPix) {
            pixDestroy(&bestPix);
        }
        bestPix = blueChannelPix;
        bestConfidence = blueConfidence;
        bestImageName = "蓝色通道";
    }

    qDebug() << "=== 测试完成 ===";
    qDebug() << "选择置信度最高的图像进行识别:" << bestImageName << "(置信度:" << bestConfidence << ")";

    // 4. 使用置信度最高的图像进行最终识别
    tesseract::TessBaseAPI *api = new tesseract::TessBaseAPI();
    QString appDir = QCoreApplication::applicationDirPath();
    QString tessdataPath = appDir + "/tessdata";
    if (api->Init(tessdataPath.toUtf8().constData(), ocrLang.toUtf8().constData())) {
        qDebug() << "Tesseract 初始化失败";
        delete api;
        // 清理所有资源
        pixDestroy(&originalPix);
        if (redChannelPix) pixDestroy(&redChannelPix);
        if (greenChannelPix) pixDestroy(&greenChannelPix);
        if (blueChannelPix) pixDestroy(&blueChannelPix);
        return "";
    }

    // 设置图像（使用置信度最高的图像）
    api->SetImage(bestPix);

    // 识别文本
    char *outText = api->GetUTF8Text();
    QString result = QString::fromUtf8(outText);

    // 清理资源
    delete[] outText;
    api->End();
    delete api;

    // 释放所有图像资源
    pixDestroy(&originalPix);
    if (redChannelPix && redChannelPix != bestPix) pixDestroy(&redChannelPix);
    if (greenChannelPix && greenChannelPix != bestPix) pixDestroy(&greenChannelPix);
    if (blueChannelPix && blueChannelPix != bestPix) pixDestroy(&blueChannelPix);
    if (bestPix != originalPix && bestPix != redChannelPix && bestPix != greenChannelPix && bestPix != blueChannelPix) {
        pixDestroy(&bestPix);
    }

    qDebug() << "OCR 识别结果:" << result;

    return result;
}

// 流式输出实现
void Widget::streamQueryLlama(const QString &prompt) {
    qDebug() << "streamQueryLlama 收到 prompt:" << prompt;
    
    // 检查模型是否已加载
    if (model == nullptr) {
        QMessageBox::warning(nullptr, "模型未加载", 
            "模型文件未加载，请先下载模型文件并在设置中配置模型路径。\n\n"
            "下载地址：https://modelscope.cn/models/Tencent-Hunyuan/HY-MT1.5-1.8B-GGUF/files");
        return;
    }
    
    // 使用llama_chat_apply_template处理消息
    struct llama_chat_message messages[] = {
        {"user", prompt.toUtf8().constData()}
    };
    
    // 分配缓冲区
    int buffer_size = 2048;
    char *buffer = new char[buffer_size];
    
    // 应用聊天模板
    int32_t prompt_length = llama_chat_apply_template(
        nullptr,  // 使用模型默认模板
        messages,
        1,        // 消息数量
        true,     // 添加assistant提示
        buffer,
        buffer_size
    );
    
    if (prompt_length <= 0) {
        delete[] buffer;
        return;
    }
    
    // 确保缓冲区足够大
    if (prompt_length >= buffer_size) {
        delete[] buffer;
        buffer_size = prompt_length + 1;
        buffer = new char[buffer_size];
        
        // 重新应用模板
        prompt_length = llama_chat_apply_template(
            nullptr,
            messages,
            1,
            true,
            buffer,
            buffer_size
        );
        
        if (prompt_length <= 0) {
            delete[] buffer;
            return;
        }
    }

    const struct llama_vocab * vocab = llama_model_get_vocab(model);

    int n_prompt = -llama_tokenize(vocab, buffer, prompt_length, nullptr, 0, true, true);
    if (n_prompt <= 0) {
        delete[] buffer;
        return;
    }
    std::vector<llama_token> prompt_tokens(n_prompt);
    llama_tokenize(vocab, buffer, prompt_length, prompt_tokens.data(), prompt_tokens.size(), true, true);
    
    // 清理缓冲区
    delete[] buffer;

    // 初始化上下文
    llama_context_params ctx_params = llama_context_default_params();
    int n_predict=512;
    ctx_params.n_ctx = n_prompt + n_predict - 1;
    ctx_params.n_batch = n_prompt;
    ctx_params.no_perf = false;

    llama_context * ctx = llama_init_from_model(model, ctx_params);
    if (ctx == NULL) {
        qDebug() << __func__ << ": error: failed to create the llama_context\n";
        return;
    }

    auto sparams = llama_sampler_chain_default_params();
    sparams.no_perf = false;
    llama_sampler * smpl = llama_sampler_chain_init(sparams);
    llama_sampler_chain_add(smpl, llama_sampler_init_top_k(20));
    llama_sampler_chain_add(smpl, llama_sampler_init_top_p(0.6f, 0));
    llama_sampler_chain_add(smpl, llama_sampler_init_penalties(
                                      64,        // penalty_last_n
                                      1.05f,     // penalty_repeat
                                      0.0f,      // penalty_freq
                                      0.0f       // penalty_present
                                      ));
    llama_sampler_chain_add(smpl, llama_sampler_init_temp(0.7f));
    llama_sampler_chain_add(smpl, llama_sampler_init_dist(1234)); // 1234 是随机种子 seed

    auto t_start = std::chrono::steady_clock::now();
    std::chrono::steady_clock::time_point t_first_token;
    bool first_token_received = false;

    // 清空上下文缓存，准备新推理
    llama_memory_seq_rm(llama_get_memory(ctx), -1, 0, -1);

    llama_batch batch = llama_batch_get_one(prompt_tokens.data(), prompt_tokens.size());

    if (llama_model_has_encoder(model)) {
        llama_encode(ctx, batch);
        llama_token bos = llama_vocab_bos(vocab);
        batch = llama_batch_get_one(&bos, 1);

        llama_token decoder_start_token_id = llama_model_decoder_start_token(model);
        if (decoder_start_token_id == LLAMA_TOKEN_NULL) {
            decoder_start_token_id = llama_vocab_bos(vocab);
        }
        batch = llama_batch_get_one(&decoder_start_token_id, 1);
    }

    int n_decode = 0;
    int n_pos = 0;

    for (int n_pos = 0; n_pos+batch.n_tokens < n_prompt + n_predict; ) {
        // 检查是否应该停止翻译
        if (shouldStopTranslation) {
            break;
        }

        if (llama_decode(ctx, batch)) break;

        n_pos += batch.n_tokens;
        llama_token id = llama_sampler_sample(smpl, ctx, -1);

        if (llama_vocab_is_eog(vocab, id)) break;

        // 首字时间统计
        if (!first_token_received) {
            t_first_token = std::chrono::steady_clock::now();
            first_token_received = true;
            double ms_to_first = std::chrono::duration<double, std::milli>(t_first_token - t_start).count();
            qDebug() << "------------------------------------------";
            qDebug() << "首字时间 (First Token Time):" << ms_to_first << "ms";
        }

        char buf[128];
        int n = llama_token_to_piece(vocab, id, buf, sizeof(buf), 0, true);
        QString tokenStr = (n > 0) ? QString::fromUtf8(buf, n) : QString();

        // 关键：流式输出
        emit streamTokenReady(tokenStr);

        batch = llama_batch_get_one(&id, 1);
        n_decode++;
    }

    // 吞吐量统计
    auto t_end = std::chrono::steady_clock::now();
    if (n_decode > 0 && first_token_received) {
        double total_gen_s = std::chrono::duration<double>(t_end - t_first_token).count();
        double tps = (n_decode > 1) ? (n_decode - 1) / total_gen_s : 0;
        qDebug() << "生成 Token 总数:" << n_decode;
        qDebug() << "平均吞吐量 (Throughput):" << tps << "tokens/sec";
        qDebug() << "每个 Token 平均耗时:" << (total_gen_s * 1000 / n_decode) << "ms";
        qDebug() << "------------------------------------------";
    }

    llama_sampler_free(smpl);
    llama_free(ctx);
}

// 注册全局热键
bool Widget::registerGlobalHotkey() {
#ifdef Q_OS_WIN
    // 获取窗口句柄
    HWND hWnd = (HWND)winId();
    
    // 从配置中获取快捷键
    ConfigManager *config = ConfigManager::instance();
    QString hotkeyStr = config->getHotkey();
    QKeySequence keySequence(hotkeyStr);
    
    // 检查快捷键是否有效
    if (keySequence.isEmpty()) {
        qDebug() << "快捷键无效，使用默认快捷键";
        keySequence = QKeySequence("Ctrl+Shift+O");
    }
    
    // 解析快捷键
    int key = keySequence[0];
    int modifiers = 0;
    
    if (key & Qt::ControlModifier) modifiers |= MOD_CONTROL;
    if (key & Qt::ShiftModifier) modifiers |= MOD_SHIFT;
    if (key & Qt::AltModifier) modifiers |= MOD_ALT;
    if (key & Qt::MetaModifier) modifiers |= MOD_WIN;
    
    // 获取实际的键码
    int vkCode = key & ~Qt::KeyboardModifierMask;
    
    // 检查是否是鼠标左键、右键或中键（这些键不允许绑定）
    if (vkCode == VK_LBUTTON || vkCode == VK_RBUTTON || vkCode == VK_MBUTTON) {
        qDebug() << "不允许绑定鼠标左键、右键或中键，使用默认快捷键";
        keySequence = QKeySequence("Ctrl+Shift+O");
        key = keySequence[0];
        modifiers = 0;
        if (key & Qt::ControlModifier) modifiers |= MOD_CONTROL;
        if (key & Qt::ShiftModifier) modifiers |= MOD_SHIFT;
        if (key & Qt::AltModifier) modifiers |= MOD_ALT;
        if (key & Qt::MetaModifier) modifiers |= MOD_WIN;
        vkCode = key & ~Qt::KeyboardModifierMask;
    } else if (vkCode == VK_XBUTTON1 || vkCode == VK_XBUTTON2) {
        // 允许绑定鼠标侧键（4、5键）
        qDebug() << "鼠标侧键绑定成功";
    }
    
    // 注册全局热键
    if (RegisterHotKey(hWnd, HOTKEY_ID, modifiers, vkCode)) {
        return true;
    } else {
        qDebug() << "注册全局热键失败，错误码:" << GetLastError();
        return false;
    }
#else
    // 非 Windows 平台不支持全局热键
    return false;
#endif
}

// 注销全局热键
void Widget::unregisterGlobalHotkey() {
#ifdef Q_OS_WIN
    // 获取窗口句柄
    HWND hWnd = (HWND)winId();
    
    // 注销全局热键
    UnregisterHotKey(hWnd, HOTKEY_ID);
#endif
}

// 处理 Windows 消息（重写）
bool Widget::nativeEvent(const QByteArray &eventType, void *message, qintptr *result) {
#ifdef Q_OS_WIN
    // 检查是否是 Windows 消息
    if (eventType == "windows_generic_MSG") {
        MSG *msg = static_cast<MSG *>(message);
        
        // 检查是否是全局热键消息
        if (msg->message == WM_HOTKEY && msg->wParam == HOTKEY_ID) {
            // 全局热键被触发，执行 OCR 功能
            qDebug() << "全局热键触发";
            onOCRShortcutTriggered();
            return true;
        }
    }
#endif
    
    // 其他消息交给父类处理
    return QWidget::nativeEvent(eventType, message, result);
}

// 置顶按钮点击事件
void Widget::onStayOnTopClicked() {
    // 切换置顶状态
    isStayOnTop = !isStayOnTop;
    
    // 设置窗口置顶属性
    if (isStayOnTop) {
        setWindowFlags(windowFlags() | Qt::WindowStaysOnTopHint);
        stayOnTopButton->setIcon(QIcon(":/resource_icon/nail.svg"));
        stayOnTopButton->setToolTip("取消置顶");
        qDebug() << "窗口已置顶";
    } else {
        setWindowFlags(windowFlags() & ~Qt::WindowStaysOnTopHint);
        stayOnTopButton->setIcon(QIcon(":/resource_icon/nail_copy.svg"));
        stayOnTopButton->setToolTip("置顶");
        qDebug() << "窗口已取消置顶";
    }
    
    // 重新显示窗口以应用新的窗口标志
    show();
}

// 设置按钮点击事件
void Widget::onSettingsButtonClicked() {
    SettingsDialog dialog(this);
    if (dialog.exec() == QDialog::Accepted) {
        // 配置已更改，重新加载配置
        ConfigManager *config = ConfigManager::instance();
        
        // 更新输入定时器延迟
        inputTimer->setInterval(config->getAutoTranslateDelay());
        
        // 重新注册快捷键
        if (ocrShortcut) {
            delete ocrShortcut;
            ocrShortcut = nullptr;
        }
        unregisterGlobalHotkey();
        
        if (config->getHotkeyEnabled()) {
            if (!registerGlobalHotkey()) {
                qDebug() << "无法注册全局热键，将使用普通快捷键作为备选";
                ocrShortcut = new QShortcut(QKeySequence(config->getHotkey()), this);
                connect(ocrShortcut, &QShortcut::activated, this, &Widget::onOCRShortcutTriggered);
            } else {
                qDebug() << "全局热键注册成功（" << config->getHotkey() << "）";
            }
        }
        
        // 处理模型路径更改
        QString newModelPath = config->getModelPath();
        
        // 如果是相对路径，转换为相对于应用程序目录的绝对路径
        QFileInfo modelFileInfo(newModelPath);
        if (modelFileInfo.isRelative()) {
            QString appDir = QCoreApplication::applicationDirPath();
            newModelPath = QDir(appDir).absoluteFilePath(newModelPath);
        }
        
        // 检查模型文件是否存在
        QFile modelFile(newModelPath);
        if (modelFile.exists()) {
            // 释放旧模型
            if (model != nullptr) {
                llama_model_free(model);
                model = nullptr;
                qDebug() << "旧模型已释放";
            }
            
            // 加载新模型
            llama_model_params mparams = llama_model_default_params();
            qDebug() << "正在加载新模型:" << newModelPath;
            model = llama_model_load_from_file(newModelPath.toUtf8().constData(), mparams);
            
            if (model != nullptr) {
                qDebug() << "新模型加载成功";
                QMessageBox::information(this, "提示", "模型已更新并加载成功");
            } else {
                qDebug() << "新模型加载失败";
                QMessageBox::critical(this, "模型加载失败", 
                    QString("新模型文件加载失败，可能原因：\n\n"
                            "1. CPU不支持AVX2指令集\n"
                            "2. 模型文件损坏\n\n"
                            "请检查模型文件后重试。"));
            }
        } else {
            // 模型文件不存在，显示警告
            QMessageBox::warning(this, "模型文件不存在", 
                "未找到模型文件，请检查路径是否正确。\n\n" + newModelPath);
        }
        
        qDebug() << "设置已更新";
    }
}