#include "main_window.h"

#include <QApplication>
#include <QDateTime>
#include <QEvent>
#include <QFile>
#include <QKeyEvent>
#include <QKeySequence>
#include <QLabel>
#include <QMenu>
#include <QMessageBox>
#include <QMouseEvent>
#include <QPoint>
#include <QScreen>
#include <QShortcut>
#include <QStackedWidget>
#include <QStatusBar>
#include <QTimer>
#include <QVBoxLayout>

#include <cstring>
#include <freerdp/codec/color.h>
#include <freerdp/locale/keyboard.h>
#include <freerdp/scancode.h>

#include "desktop_list_page.h"
#include "login_page.h"

namespace vdi {
namespace {

// FreeRDP 像素格式 -> QImage::Format
// 注意：FreeRDP 的像素格式值是计算宏（FREERDP_PIXEL_FORMAT），
// 不能硬编码数值，必须用宏直接比较。
// FreeRDP 主缓冲是 4 字节/像素（BGRX / BGRA / RGBA），
// QImage 没有对应的 4 字节 BGRA 格式，因此统一转成 RGB888 输出。
QImage::Format toQImageFormat(uint32_t freerdpFormat) {
    (void)freerdpFormat;
    return QImage::Format_RGB888;
}

// FreeRDP BGRX32 在当前 ARM64 小端目标上与 QImage::Format_RGB32 的内存布局一致。
QImage convertFrame(const uint8_t* data, uint32_t width, uint32_t height, uint32_t bytesPerLine,
                    uint32_t freerdpFormat) {
    if (!data || width == 0 || height == 0) {
        return QImage();
    }
    if (freerdpFormat == PIXEL_FORMAT_BGRX32 || freerdpFormat == PIXEL_FORMAT_BGRA32) {
        QImage out(static_cast<int>(width), static_cast<int>(height), QImage::Format_RGB32);
        const size_t rowBytes = static_cast<size_t>(width) * 4;
        for (uint32_t y = 0; y < height; ++y) {
            std::memcpy(out.scanLine(static_cast<int>(y)),
                        data + static_cast<size_t>(y) * bytesPerLine, rowBytes);
        }
        return out;
    }

    QImage out(static_cast<int>(width), static_cast<int>(height), QImage::Format_RGB888);
    for (uint32_t y = 0; y < height; ++y) {
        const uint8_t* src = data + static_cast<size_t>(y) * bytesPerLine;
        uint8_t* dst = out.scanLine(static_cast<int>(y));
        for (uint32_t x = 0; x < width; ++x) {
            const uint8_t* p = src + static_cast<size_t>(x) * 4;
            dst[0] = p[0];
            dst[1] = p[1];
            dst[2] = p[2];
            dst += 3;
        }
    }
    return out;
}

constexpr int kReconnectDelayMs = 3000;
constexpr int kMaxReconnectAttempts = 5;

}  // namespace

MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent) {
    fsm_ = StateMachine([this](State from, State to, const QString& detail) {
        onStateChanged(from, to, detail);
    });
    setupUi();
    setupHotkey();
    setupHeartbeat();
    keyboardLayout_ = freerdp_keyboard_init(0);

    config_ = loadConfig();

    // 开机永远进入登录页；不再根据本地配置自动连接 RDP，
    // 会话只能由用户在桌面列表选择后启动。
    fsm_.transitionTo(State::kConfig, QStringLiteral("等待登录"));
    showLogin();
}

MainWindow::~MainWindow() {
    stopSessions();
}

void MainWindow::setupUi() {
    setWindowTitle(QStringLiteral("VDI 云终端"));
    setWindowState(Qt::WindowFullScreen);
    setStyleSheet(QStringLiteral("QMainWindow { background: #0f1420; }"));

    stack_ = new QStackedWidget(this);
    stack_->setStyleSheet(QStringLiteral("background: #0f1420;"));
    setCentralWidget(stack_);

    // 登录页
    auto* login = new LoginPage(config_, this);
    loginPage_ = login;
    login->setStyleSheet(
        QStringLiteral("QWidget { background: #0f1420; color: #e6e9ef; }"
                       "QLineEdit { background: #1a2233; border: 1px solid #2b3654; "
                       "border-radius: 4px; padding: 8px; color: #e6e9ef; }"
                       "QLineEdit:focus { border: 1px solid #2f6feb; }"
                       "QPushButton { background: #232d44; border: 1px solid #2b3654; "
                       "border-radius: 6px; color: #e6e9ef; }"
                       "QPushButton:hover { background: #2b3654; }"));
    stack_->addWidget(login);

    connect(login, &LoginPage::loginRequested, this, &MainWindow::onLoginRequested);
    connect(login, &LoginPage::quitRequested, this, &MainWindow::onQuitRequested);

    // 桌面列表页
    auto* list = new DesktopListPage(this);
    desktopListPage_ = list;
    list->setStyleSheet(
        QStringLiteral("QWidget { background: #0f1420; color: #e6e9ef; }"
                       "QPushButton { background: #232d44; border: 1px solid #2b3654; "
                       "border-radius: 6px; color: #e6e9ef; }"
                       "QPushButton:hover { background: #2b3654; }"));
    stack_->addWidget(list);

    connect(list, &DesktopListPage::desktopSelected, this, &MainWindow::onDesktopSelected);
    connect(list, &DesktopListPage::logoutRequested, this, &MainWindow::onLogoutRequested);

    // 会话视图
    auto* sessionWidget = new QWidget(this);
    auto* sessionLayout = new QVBoxLayout(sessionWidget);
    sessionLayout->setContentsMargins(0, 0, 0, 0);

    sessionView_ = new QLabel(sessionWidget);
    sessionView_->setFocusPolicy(Qt::StrongFocus);
    sessionView_->setMouseTracking(true);
    sessionView_->installEventFilter(this);
    sessionView_->setAlignment(Qt::AlignCenter);
    sessionView_->setStyleSheet(QStringLiteral("background: #000000; color: #e6e9ef;"));
    sessionView_->setText(QStringLiteral("正在建立远程会话…"));

    sessionOverlay_ = new QLabel(sessionWidget);
    sessionOverlay_->setAlignment(Qt::AlignCenter);
    sessionOverlay_->setStyleSheet(
        QStringLiteral("background: rgba(15,20,32,0.82); color: #e6e9ef; "
                       "font-size: 20px; padding: 40px;"));
    sessionOverlay_->setText(QStringLiteral("正在连接…"));
    sessionOverlay_->hide();

    sessionLayout->addWidget(sessionView_);
    sessionLayout->addWidget(sessionOverlay_);
    stack_->addWidget(sessionWidget);

    // 状态条
    statusBar_ = new QStatusBar(this);
    statusBar_->setStyleSheet(QStringLiteral("QStatusBar { background: #161d2e; color: #8a94a6; }"));
    setStatusBar(statusBar_);

    // RDP 重连定时器
    reconnectTimer_ = new QTimer(this);
    reconnectTimer_->setSingleShot(true);
    connect(reconnectTimer_, &QTimer::timeout, this, [this]() {
        if (fsm_.current() == State::kReconnect && reconnectAttempts_ < kMaxReconnectAttempts) {
            ++reconnectAttempts_;
            if (activeTicket_.protocol == Protocol::kMoonlight) {
                startMoonlightSession(activeTicket_);
            } else {
                startRdpSession(activeTicket_);
            }
        } else if (fsm_.current() == State::kReconnect) {
            stopSessions();
            fsm_.transitionTo(State::kDesktopList, QStringLiteral("重连失败，已返回桌面列表"));
        }
    });

    frameRefreshTimer_ = new QTimer(this);
    frameRefreshTimer_->setInterval(33);
    connect(frameRefreshTimer_, &QTimer::timeout, this, &MainWindow::onFrameRefresh);
    frameRefreshTimer_->start();
}

void MainWindow::setupHotkey() {
    // 全局热键 Ctrl+Alt+Shift+M 呼出管理菜单（方案 3.2 节）
    auto* shortcut = new QShortcut(QKeySequence(QStringLiteral("Ctrl+Alt+Shift+M")), this);
    shortcut->setContext(Qt::ApplicationShortcut);
    connect(shortcut, &QShortcut::activated, this, [this]() { onMenuAction(0); });
}

void MainWindow::setupHeartbeat() {
    // 定期写心跳文件，供看门狗 Monitor 判断主进程是否假死
    // 对应会议纪要要求的双进程架构
    const QString path = QStringLiteral("/tmp/vdi-kiosk.heartbeat");
    heartbeatTimer_ = new QTimer(this);
    heartbeatTimer_->setInterval(5000);
    connect(heartbeatTimer_, &QTimer::timeout, this, [path]() {
        QFile file(path);
        if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
            file.write(QByteArray::number(QDateTime::currentSecsSinceEpoch()));
            file.close();
        }
    });
    heartbeatTimer_->start();
}

void MainWindow::onStateChanged(State from, State to, const QString& detail) {
    Q_UNUSED(from);
    const QString stateName = QString::fromLatin1(stateToString(to));
    updateStatusBar(detail.isEmpty() ? stateName : QStringLiteral("%1  %2").arg(stateName, detail));

    switch (to) {
        case State::kConfig:
            showLogin();
            break;
        case State::kAuthenticating:
            break;
        case State::kDesktopList:
            showDesktopList();
            refreshDesktopList();
            break;
        case State::kConnecting:
            if (stack_->currentWidget() != sessionView_->parentWidget()) {
                stack_->setCurrentWidget(sessionView_->parentWidget());
            }
            sessionView_->setFocus(Qt::OtherFocusReason);
            sessionOverlay_->setText(QStringLiteral("正在连接 %1 …").arg(activeTicket_.endpoint));
            sessionOverlay_->show();
            break;
        case State::kSession:
            sessionView_->setFocus(Qt::OtherFocusReason);
            sessionOverlay_->hide();
            break;
        case State::kReconnect:
            sessionOverlay_->setText(QStringLiteral("连接已断开，正在重连…"));
            sessionOverlay_->show();
            reconnectTimer_->start(kReconnectDelayMs);
            break;
        case State::kError:
            stopSessions();
            fsm_.transitionTo(State::kDesktopList, QStringLiteral("连接失败"));
            if (desktopListPage_) {
                desktopListPage_->setBusy(false);
                desktopListPage_->setStatus(QStringLiteral("连接失败：%1").arg(detail), true);
            }
            break;
        case State::kBoot:
            break;
    }
}

void MainWindow::updateStatusBar(const QString& text) {
    statusBar_->showMessage(text);
}

void MainWindow::showLogin() {
    stack_->setCurrentWidget(loginPage_);
    if (loginPage_) {
        loginPage_->setBusy(false);
        loginPage_->setStatus(QStringLiteral("请输入用户名和密码登录"));
    }
}

void MainWindow::showDesktopList() {
    if (!desktopListPage_) {
        return;
    }
    stack_->setCurrentWidget(desktopListPage_);
    desktopListPage_->setCurrentUser(currentUser_);
    desktopListPage_->setBusy(false);
}

void MainWindow::refreshDesktopList() {
    desktopService_.listDesktops([this](std::vector<DesktopInfo> list, const QString& error) {
        if (error.isEmpty()) {
            desktops_ = list;
        }
        if (desktopListPage_) {
            desktopListPage_->setDesktops(desktops_);
            if (!error.isEmpty()) {
                desktopListPage_->setStatus(error, true);
            }
        }
    });
}

void MainWindow::onLoginRequested(const QString& username, const QString& password) {
    desktopService_.login(username, password, [this](const AuthResult& result) {
        if (!loginPage_) {
            return;
        }
        if (!result.ok) {
            loginPage_->setBusy(false);
            loginPage_->setStatus(result.message, true);
            return;
        }
        currentUser_ = result.displayName;
        fsm_.transitionTo(State::kAuthenticating, QStringLiteral("认证成功"));
        fsm_.transitionTo(State::kDesktopList, QStringLiteral("欢迎 %1").arg(currentUser_));
    });
}

void MainWindow::onDesktopSelected(const QString& desktopId) {
    if (!fsm_.canConnect()) {
        return;
    }
    desktopService_.createTicket(desktopId, [this](const ConnectionTicket& ticket,
                                                   const QString& error) {
        if (!error.isEmpty()) {
            if (desktopListPage_) {
                desktopListPage_->setBusy(false);
                desktopListPage_->setStatus(error, true);
            }
            return;
        }
        activeTicket_ = ticket;
        reconnectAttempts_ = 0;

        if (ticket.protocol == Protocol::kMoonlight) {
            startMoonlightSession(ticket);
        } else {
            startRdpSession(ticket);
        }
    });
}

void MainWindow::onLogoutRequested() {
    stopSessions();
    desktopService_.logout();
    currentUser_.clear();
    fsm_.transitionTo(State::kConfig, QStringLiteral("已退出登录"));
}

void MainWindow::startRdpSession(const ConnectionTicket& ticket) {
    ++sessionEpoch_;
    {
        QMutexLocker locker(&frameMutex_);
        latestFrame_ = QImage();
        frameEpoch_ = sessionEpoch_;
        frameWakePending_ = false;
    }
    if (fsm_.current() == State::kSession) {
        fsm_.transitionTo(State::kReconnect, QStringLiteral("手动重新连接"));
    }
    if (!fsm_.transitionTo(State::kConnecting, ticket.endpoint)) {
        if (fsm_.current() != State::kConnecting) {
            return;
        }
    }

    RdpOptions opts;
    opts.server = ticket.endpoint.toStdString();
    opts.username = ticket.username.toStdString();
    opts.password = ticket.password.toStdString();
    opts.keyboardLayout = keyboardLayout_;
    opts.width = ticket.width;
    opts.height = ticket.height;
    opts.bpp = 32;
    opts.fullscreen = true;
    // 与 xfreerdp3 相同的 GFX 能力组合语义：
    // FreeRDP 3.32.1 不接受单个管道名，必须成组。
    opts.gfx = "progressive|RFX|AVC420|AVC444";
    opts.ignoreCertificate = true;  // POC 阶段；正式产品必须做证书校验

    RdpCallbacks cb;
    cb.onFrame = [this](const uint8_t* data, uint32_t width, uint32_t height, uint32_t stride,
                        uint32_t format) {
        // 在 FreeRDP 线程中复制帧，不能把其内部缓冲区裸指针排队到 GUI 线程。
        const QImage image = convertFrame(data, width, height, stride, format);
        if (image.isNull()) {
            return;
        }
        QMutexLocker locker(&frameMutex_);
        latestFrame_ = image;
        frameEpoch_ = sessionEpoch_;
        if (frameWakePending_) {
            return;
        }
        frameWakePending_ = true;
        locker.unlock();
        QMetaObject::invokeMethod(this, &MainWindow::onFrameWakeup, Qt::QueuedConnection);
    };
    cb.onState = [this](bool connected, const std::string& message) {
        QMetaObject::invokeMethod(
            this,
            [this, connected, message]() {
                onSessionState(connected, QString::fromStdString(message));
            },
            Qt::QueuedConnection);
    };

    rdpSession_ = std::make_unique<RdpSession>();
    rdpSession_->start(opts, cb);
}

void MainWindow::startMoonlightSession(const ConnectionTicket& ticket) {
    if (!fsm_.transitionTo(State::kConnecting, ticket.endpoint)) {
        if (fsm_.current() != State::kConnecting) {
            return;
        }
    }
    // Moonlight 是外部全屏进程：Kiosk 画面停在"正在连接"覆盖层，
    // 串流窗口由 moonlight-qt 自行置顶显示。
    if (stack_->currentWidget() != sessionView_->parentWidget()) {
        stack_->setCurrentWidget(sessionView_->parentWidget());
    }
    sessionOverlay_->setText(QStringLiteral("正在连接 %1 …").arg(ticket.endpoint));
    sessionOverlay_->show();

    MoonlightSession::Options opts;
    opts.decoder = QStringLiteral("software");  // RK3528 无可用 V4L2 硬解设备
    opts.videoCodec = QStringLiteral("H.264");
    opts.audioOnHost = true;

    moonlightSession_ = std::make_unique<MoonlightSession>(/*parent=*/nullptr);
    moonlightSession_->setOptions(opts);
    moonlightSession_->start(ticket, [this](bool running, const QString& message) {
        QMetaObject::invokeMethod(
            this,
            [this, running, message]() { onMoonlightState(running, message); },
            Qt::QueuedConnection);
    });
}

void MainWindow::onMoonlightState(bool running, const QString& message) {
    if (running) {
        // 进程已拉起；串流窗口是否成功由 moonlight 自身展示
        updateStatusBar(QStringLiteral("SESSION  %1").arg(message));
        return;
    }
    // 进程退出：回桌面列表
    moonlightSession_.reset();
    stopSessions();
    if (fsm_.current() == State::kConnecting || fsm_.current() == State::kSession) {
        fsm_.transitionTo(State::kDesktopList, message);
    }
    if (desktopListPage_) {
        desktopListPage_->setBusy(false);
        desktopListPage_->setStatus(message);
    }
}

void MainWindow::onSessionState(bool connected, const QString& message) {
    if (connected) {
        reconnectAttempts_ = 0;
        fsm_.transitionTo(State::kSession, message);
    } else {
        if (fsm_.current() == State::kConnecting) {
            // 首次连接失败：回桌面列表并提示
            stopSessions();
            fsm_.transitionTo(State::kDesktopList, message);
            if (desktopListPage_) {
                desktopListPage_->setBusy(false);
                desktopListPage_->setStatus(QStringLiteral("连接失败：%1").arg(message), true);
            }
        } else if (fsm_.current() == State::kSession) {
            fsm_.transitionTo(State::kReconnect, message);
        }
    }
}

void MainWindow::onFrameWakeup() {
    QMutexLocker locker(&frameMutex_);
    frameWakePending_ = false;
}

void MainWindow::onFrameRefresh() {
    QImage image;
    uint64_t epoch = 0;
    {
        QMutexLocker locker(&frameMutex_);
        image = latestFrame_;
        epoch = frameEpoch_;
        latestFrame_ = QImage();
        frameWakePending_ = false;
    }
    if (epoch == sessionEpoch_) {
        onFrameImage(image);
    }
}

void MainWindow::onFrameImage(const QImage& image) {
    if (image.isNull()) {
        return;
    }
    lastFrame_ = image;

    if (sessionView_) {
        const QSize targetSize = sessionView_->size();
        if (lastFrame_.size() == targetSize) {
            sessionView_->setPixmap(QPixmap::fromImage(lastFrame_));
        } else {
            sessionView_->setPixmap(QPixmap::fromImage(lastFrame_).scaled(
                targetSize, Qt::KeepAspectRatio, Qt::FastTransformation));
        }
    }
}

void MainWindow::onQuitRequested() {
    stopSessions();
    QApplication::quit();
}

void MainWindow::stopSessions() {
    if (rdpSession_) {
        rdpSession_->stop();
        rdpSession_.reset();
    }
    if (moonlightSession_) {
        moonlightSession_->stop();
        moonlightSession_.reset();
    }
    QMutexLocker locker(&frameMutex_);
    latestFrame_ = QImage();
    lastFrame_ = QImage();
    frameWakePending_ = false;
}

void MainWindow::onMenuAction(int action) {
    switch (action) {
        case 1:  // 重新连接当前桌面
            if (fsm_.canConnect() && !activeTicket_.desktopId.isEmpty()) {
                reconnectAttempts_ = 0;
                stopSessions();
                if (activeTicket_.protocol == Protocol::kMoonlight) {
                    startMoonlightSession(activeTicket_);
                } else {
                    startRdpSession(activeTicket_);
                }
            }
            break;
        case 2:  // 断开回桌面列表
            stopSessions();
            if (fsm_.current() != State::kConfig) {
                fsm_.transitionTo(State::kDesktopList, "已断开");
            }
            break;
        case 3:  // 退出终端
            onQuitRequested();
            break;
        default: {
            QMenu menu(this);
            QAction* reconnect = menu.addAction(QStringLiteral("重新连接当前桌面"));
            QAction* disconnect = menu.addAction(QStringLiteral("断开并返回桌面列表"));
            menu.addSeparator();
            QAction* quit = menu.addAction(QStringLiteral("退出终端"));
            QAction* chosen = menu.exec(QCursor::pos());
            if (chosen == reconnect) {
                onMenuAction(1);
            } else if (chosen == disconnect) {
                onMenuAction(2);
            } else if (chosen == quit) {
                onMenuAction(3);
            }
            if (stack_->currentWidget() == sessionView_->parentWidget()) {
                sessionView_->setFocus(Qt::OtherFocusReason);
            }
            break;
        }
    }
}

bool MainWindow::eventFilter(QObject* watched, QEvent* event) {
    if (watched == sessionView_ && rdpSession_) {
        if (event->type() == QEvent::KeyPress || event->type() == QEvent::KeyRelease) {
            auto* keyEvent = static_cast<QKeyEvent*>(event);
            return forwardKeyEvent(keyEvent, event->type() == QEvent::KeyPress);
        }
        if (event->type() == QEvent::MouseMove || event->type() == QEvent::MouseButtonPress ||
            event->type() == QEvent::MouseButtonRelease) {
            return forwardMouseEvent(static_cast<QMouseEvent*>(event));
        }
        if (event->type() == QEvent::Wheel) {
            return forwardMouseEvent(event);
        }
    }
    return QMainWindow::eventFilter(watched, event);
}

bool MainWindow::forwardKeyEvent(QKeyEvent* event, bool pressed) {
    if (!rdpSession_) {
        return false;
    }
    const DWORD rdpScanCode =
        freerdp_keyboard_get_rdp_scancode_from_x11_keycode(event->nativeScanCode());
    if (rdpScanCode == RDP_SCANCODE_UNKNOWN) {
        return false;
    }
    return rdpSession_->sendKeyEvent(pressed, event->isAutoRepeat(), rdpScanCode);
}

bool MainWindow::forwardMouseEvent(QEvent* event) {
    if (!rdpSession_) {
        return false;
    }
    uint16_t flags = 0;
    QPoint pos = lastMousePosition_;
    if (event->type() == QEvent::MouseMove) {
        auto* mouse = static_cast<QMouseEvent*>(event);
        pos = mouse->pos();
        flags = PTR_FLAGS_MOVE;
    } else if (event->type() == QEvent::MouseButtonPress ||
               event->type() == QEvent::MouseButtonRelease) {
        auto* mouse = static_cast<QMouseEvent*>(event);
        pos = mouse->pos();
        if (mouse->button() == Qt::LeftButton) flags |= PTR_FLAGS_BUTTON1;
        if (mouse->button() == Qt::RightButton) flags |= PTR_FLAGS_BUTTON2;
        if (mouse->button() == Qt::MiddleButton) flags |= PTR_FLAGS_BUTTON3;
        if (event->type() == QEvent::MouseButtonPress) flags |= PTR_FLAGS_DOWN;
    } else if (event->type() == QEvent::Wheel) {
        auto* wheel = static_cast<QWheelEvent*>(event);
        pos = wheel->position().toPoint();
        flags = PTR_FLAGS_WHEEL;
        if (wheel->angleDelta().y() < 0) flags |= PTR_FLAGS_WHEEL_NEGATIVE;
    }
    lastMousePosition_ = pos;

    if (lastFrame_.isNull() || !sessionView_) {
        return false;
    }
    const QSize sourceSize = lastFrame_.size();
    const QSize viewSize = sessionView_->size();
    const QSize displayedSize = sourceSize.scaled(viewSize, Qt::KeepAspectRatio);
    const int offsetX = (viewSize.width() - displayedSize.width()) / 2;
    const int offsetY = (viewSize.height() - displayedSize.height()) / 2;
    if (pos.x() < offsetX || pos.y() < offsetY ||
        pos.x() >= offsetX + displayedSize.width() ||
        pos.y() >= offsetY + displayedSize.height()) {
        return true;
    }
    const int remoteX = qBound(0,
        (pos.x() - offsetX) * sourceSize.width() / displayedSize.width(),
        sourceSize.width() - 1);
    const int remoteY = qBound(0,
        (pos.y() - offsetY) * sourceSize.height() / displayedSize.height(),
        sourceSize.height() - 1);
    return rdpSession_->sendMouseEvent(flags, static_cast<uint16_t>(remoteX),
                                       static_cast<uint16_t>(remoteY));
}

}  // namespace vdi