mainwindow.cpp

#include "mainwindow.h"

#include <QCheckBox>
#include <QFileDialog>
#include <QJsonArray>
#include <QHBoxLayout>
#include <QInputDialog>
#include <QLabel>
#include <QPushButton>
#include <QShortcut>
#include <QStackedWidget>
#include <QTimer>
#include <QVBoxLayout>

#include "boardsnapshot.h"
#include "boardwidget.h"
#include "netcli.h"

namespace {

QLabel* makeTitle(const QString& text, int pointSize)
{
    auto* label = new QLabel(text);
    label->setAlignment(Qt::AlignCenter);
    QFont f = label->font();
    f.setPointSize(pointSize);
    f.setBold(true);
    label->setFont(f);
    return label;
}

QPushButton* makeButton(const QString& text, int minHeight = 36)
{
    auto* btn = new QPushButton(text);
    btn->setMinimumHeight(minHeight);
    btn->setCursor(Qt::PointingHandCursor);
    return btn;
}

QString resultText(GameModel::ActionResult r)
{
    switch (r) {
    case GameModel::ActionResult::RevealedEmpty: return QStringLiteral("已揭开该格：是水域。");
    case GameModel::ActionResult::RevealedShip:  return QStringLiteral("已揭开该格：发现敌舰！");
    case GameModel::ActionResult::Turned:        return QStringLiteral("已转向 90°。");
    case GameModel::ActionResult::Moved:         return QStringLiteral("已前进一格。");
    case GameModel::ActionResult::Collided:      return QStringLiteral("碰撞！本舰血量变为 1，移动被挡。");
    case GameModel::ActionResult::Hit:           return QStringLiteral("命中敌舰（-1 血量）。");
    case GameModel::ActionResult::Sunk:          return QStringLiteral("命中并击沉敌舰！");
    case GameModel::ActionResult::Passed:        return QStringLiteral("已跳过回合。");
    case GameModel::ActionResult::Surrendered:   return QStringLiteral("已投降。");
    default:                                     return QStringLiteral("行动完成。");
    }
}

} // namespace

MainWindow::MainWindow(QWidget* parent)
    : QMainWindow(parent)
{
    setWindowTitle(QStringLiteral("战舰对战"));

    m_model = new GameModel(this);

    m_stack = new QStackedWidget(this);
    setCentralWidget(m_stack);

    m_menuPage = buildMenuPage();
    m_gamePage = buildGamePage();
    m_promptPage = buildPromptPage();
    m_endPage = buildEndPage();

    m_stack->addWidget(m_menuPage);
    m_stack->addWidget(m_gamePage);
    m_stack->addWidget(m_promptPage);
    m_stack->addWidget(m_endPage);
    m_stack->setCurrentWidget(m_menuPage);

    m_obsTimer = new QTimer(this);
    m_obsTimer->setInterval(1000);
    connect(m_obsTimer, &QTimer::timeout, this, &MainWindow::onObsTick);

    m_handoffTimer = new QTimer(this);
    m_handoffTimer->setSingleShot(true);
    connect(m_handoffTimer, &QTimer::timeout, this, &MainWindow::onHandoffTimeout);

    m_aiTimer = new QTimer(this);
    m_aiTimer->setSingleShot(true);
    connect(m_aiTimer, &QTimer::timeout, this, &MainWindow::onAiTurnTimeout);

    connect(m_model, &GameModel::boardChanged, this, &MainWindow::onBoardChanged);

    auto* esc = new QShortcut(QKeySequence(Qt::Key_Escape), this);
    connect(esc, &QShortcut::activated, this, &MainWindow::cancelSelection);

    auto* undoSc = new QShortcut(QKeySequence(QStringLiteral("Ctrl+Z")), this);
    connect(undoSc, &QShortcut::activated, this, &MainWindow::onUndo);

    auto* redoSc = new QShortcut(QKeySequence(QStringLiteral("Ctrl+Y")), this);
    connect(redoSc, &QShortcut::activated, this, &MainWindow::onRedo);

    resize(580, 820);
}

// ---------------------------------------------------------------------------
// 页面构建
// ---------------------------------------------------------------------------

QWidget* MainWindow::buildMenuPage()
{
    auto* page = new QWidget;
    auto* layout = new QVBoxLayout(page);
    layout->setContentsMargins(40, 40, 40, 40);
    layout->setSpacing(14);

    layout->addStretch();
    layout->addWidget(makeTitle(QStringLiteral("《战舰对战》"), 30));

    auto* rules = new QLabel(QStringLiteral(
        "9×9 棋盘 · 双方各 5 艘战舰（体积 1~5）\n"
        "开局被迷雾笼罩，行/列提示显示占用格数\n"
        "每回合四选一：解雾 / 转向 / 移动 / 攻击\n"
        "攻击力 1 · 血量 = 体积 · 射程 = 体积²\n"
        "击沉敌方全部战舰即可获胜"));
    rules->setAlignment(Qt::AlignCenter);
    layout->addWidget(rules);
    layout->addSpacing(20);

    m_aiCheck = new QCheckBox(QStringLiteral("人机对战（玩家2 由 AI 控制）"));
    m_aiCheck->setCursor(Qt::PointingHandCursor);
    layout->addWidget(m_aiCheck);

    auto* startBtn = makeButton(QStringLiteral("开始游戏"), 48);
    connect(startBtn, &QPushButton::clicked, this, &MainWindow::onStartClicked);
    layout->addWidget(startBtn);

    auto* onlineBtn = makeButton(QStringLiteral("在线对战"), 44);
    connect(onlineBtn, &QPushButton::clicked, this, &MainWindow::onStartOnline);
    layout->addWidget(onlineBtn);

    layout->addStretch();
    return page;
}

QWidget* MainWindow::buildGamePage()
{
    auto* page = new QWidget;
    auto* layout = new QVBoxLayout(page);
    layout->setContentsMargins(16, 12, 16, 12);
    layout->setSpacing(8);

    m_status = new QLabel;
    m_status->setAlignment(Qt::AlignCenter);
    layout->addWidget(m_status);

    m_board = new BoardWidget;
    layout->addWidget(m_board, 1);

    m_shipInfo = new QLabel;
    m_shipInfo->setAlignment(Qt::AlignCenter);
    layout->addWidget(m_shipInfo);

    // 观察阶段横幅 + 跳过按钮
    auto* obsRow = new QHBoxLayout;
    m_obsBanner = new QLabel;
    m_obsBanner->setAlignment(Qt::AlignCenter);
    m_skipObsBtn = makeButton(QStringLiteral("跳过观察"));
    m_skipObsBtn->setFixedWidth(120);
    connect(m_skipObsBtn, &QPushButton::clicked, this, &MainWindow::onSkipObserve);
    obsRow->addWidget(m_obsBanner, 1);
    obsRow->addWidget(m_skipObsBtn);
    layout->addLayout(obsRow);

    // 动作按钮（两行）
    auto* row1 = new QHBoxLayout;
    m_fogBtn = makeButton(QStringLiteral("解雾"));
    m_moveBtn = makeButton(QStringLiteral("移动"));
    m_attackBtn = makeButton(QStringLiteral("攻击"));
    connect(m_fogBtn, &QPushButton::clicked, this, &MainWindow::onFogAction);
    connect(m_moveBtn, &QPushButton::clicked, this, &MainWindow::onMoveAction);
    connect(m_attackBtn, &QPushButton::clicked, this, &MainWindow::onAttackAction);
    row1->addWidget(m_fogBtn);
    row1->addWidget(m_moveBtn);
    row1->addWidget(m_attackBtn);
    layout->addLayout(row1);

    auto* row2 = new QHBoxLayout;
    m_turnLBtn = makeButton(QStringLiteral("左转 90°"));
    m_turnRBtn = makeButton(QStringLiteral("右转 90°"));
    m_passBtn = makeButton(QStringLiteral("跳过回合"));
    m_aiBtn = makeButton(QStringLiteral("AI 代打"));
    connect(m_turnLBtn, &QPushButton::clicked, this, &MainWindow::onTurnLeft);
    connect(m_turnRBtn, &QPushButton::clicked, this, &MainWindow::onTurnRight);
    connect(m_passBtn, &QPushButton::clicked, this, &MainWindow::onPassAction);
    connect(m_aiBtn, &QPushButton::clicked, this, &MainWindow::onAiPlay);
    row2->addWidget(m_turnLBtn);
    row2->addWidget(m_turnRBtn);
    row2->addWidget(m_passBtn);
    row2->addWidget(m_aiBtn);
    layout->addLayout(row2);

    // 撤销 / 重做 / 保存复盘 / 重新开始 / 返回菜单
    auto* row3 = new QHBoxLayout;
    m_undoBtn = makeButton(QStringLiteral("撤销"));
    m_redoBtn = makeButton(QStringLiteral("重做"));
    auto* saveBtn = makeButton(QStringLiteral("保存复盘"));
    auto* surrenderBtn = makeButton(QStringLiteral("投降"));
    auto* restartBtn = makeButton(QStringLiteral("重新开始"));
    auto* menuBtn = makeButton(QStringLiteral("返回菜单"));
    connect(m_undoBtn, &QPushButton::clicked, this, &MainWindow::onUndo);
    connect(m_redoBtn, &QPushButton::clicked, this, &MainWindow::onRedo);
    connect(saveBtn, &QPushButton::clicked, this, &MainWindow::onSaveReplay);
    connect(surrenderBtn, &QPushButton::clicked, this, &MainWindow::onSurrender);
    connect(restartBtn, &QPushButton::clicked, this, &MainWindow::onRestart);
    connect(menuBtn, &QPushButton::clicked, this, &MainWindow::onBackToMenu);
    row3->addWidget(m_undoBtn);
    row3->addWidget(m_redoBtn);
    row3->addWidget(saveBtn);
    row3->addWidget(surrenderBtn);
    row3->addWidget(restartBtn);
    row3->addWidget(menuBtn);
    layout->addLayout(row3);

    connect(m_board, &BoardWidget::cellClicked, this, &MainWindow::onCellClicked);

    return page;
}

QWidget* MainWindow::buildPromptPage()
{
    auto* page = new QWidget;
    auto* layout = new QVBoxLayout(page);
    layout->setContentsMargins(40, 40, 40, 40);
    layout->setSpacing(18);

    layout->addStretch();
    m_promptTitle = makeTitle(QString(), 26);
    layout->addWidget(m_promptTitle);

    m_promptSub = new QLabel;
    m_promptSub->setAlignment(Qt::AlignCenter);
    m_promptSub->setWordWrap(true);
    layout->addWidget(m_promptSub);

    layout->addSpacing(10);
    m_promptBtn = makeButton(QString(), 48);
    connect(m_promptBtn, &QPushButton::clicked, this, &MainWindow::onPromptButton);
    layout->addWidget(m_promptBtn);
    layout->addStretch();

    return page;
}

QWidget* MainWindow::buildEndPage()
{
    auto* page = new QWidget;
    auto* layout = new QVBoxLayout(page);
    layout->setContentsMargins(24, 16, 24, 16);
    layout->setSpacing(10);

    m_endTitle = makeTitle(QString(), 22);
    layout->addWidget(m_endTitle);

    m_boardFinal = new BoardWidget;
    layout->addWidget(m_boardFinal);

    auto* againBtn = makeButton(QStringLiteral("再来一局"), 44);
    auto* menuBtn = makeButton(QStringLiteral("返回菜单"), 44);
    connect(againBtn, &QPushButton::clicked, this, &MainWindow::onRestart);
    connect(menuBtn, &QPushButton::clicked, this, &MainWindow::onBackToMenu);
    layout->addWidget(againBtn);
    layout->addWidget(menuBtn);

    return page;
}

// ---------------------------------------------------------------------------
// 流程
// ---------------------------------------------------------------------------

void MainWindow::onStartClicked()
{
    m_aiOpponent = m_aiCheck->isChecked();
    m_model->newGame();
    showPrompt(QStringLiteral("玩家1观察阶段"),
               QStringLiteral("请玩家1就位。你将看到自己的舰队与行/列提示，敌方被迷雾隐藏。"),
               QStringLiteral("开始观察"),
               PromptRole::Observe1);
}

void MainWindow::onPromptButton()
{
    switch (m_promptRole) {
    case PromptRole::Observe1: beginObserve(0); break;
    case PromptRole::Observe2: beginObserve(1); break;
    case PromptRole::Turn:     beginTurn();     break;
    default: break;
    }
}

void MainWindow::beginObserve(int player)
{
    m_phase = (player == 0) ? Phase::Observe1 : Phase::Observe2;
    m_viewPlayer = player;
    refreshBoard();
    m_obsRemaining = 10;
    m_obsBanner->setText(QStringLiteral("观察阶段 %1 秒（可跳过）").arg(m_obsRemaining));
    resetSelection();
    updateShipInfo();
    updateStatus();
    m_stack->setCurrentWidget(m_gamePage);
    m_obsTimer->start();
}

void MainWindow::onObsTick()
{
    m_obsRemaining--;
    if (m_obsRemaining <= 0) {
        m_obsTimer->stop();
        endObserve();
    } else {
        m_obsBanner->setText(QStringLiteral("观察阶段 %1 秒（可跳过）").arg(m_obsRemaining));
    }
}

void MainWindow::onSkipObserve()
{
    m_obsTimer->stop();
    endObserve();
}

void MainWindow::endObserve()
{
    if (m_phase == Phase::Observe1 && !m_aiOpponent) {
        showPrompt(QStringLiteral("玩家2观察阶段"),
                   QStringLiteral("请玩家2就位。你将看到自己的舰队与行/列提示，敌方被迷雾隐藏。"),
                   QStringLiteral("开始观察"),
                   PromptRole::Observe2);
    } else {
        showPrompt(QStringLiteral("轮到 玩家%1").arg(m_model->currentPlayer() + 1),
                   QStringLiteral("点击开始回合"),
                   QStringLiteral("开始回合"),
                   PromptRole::Turn);
    }
}

void MainWindow::beginTurn()
{
    m_phase = Phase::Play;
    m_waiting = false;
    m_viewPlayer = m_model->currentPlayer();
    refreshBoard();
    resetSelection();
    updateShipInfo();
    updateStatus();
    m_stack->setCurrentWidget(m_gamePage);
}

void MainWindow::onBoardChanged()
{
    if (m_phase != Phase::Play)
        return;

    refreshBoard();

    int w = m_model->winner();
    if (w != -1) {
        endGame(w);
        return;
    }
    if (m_model->lastResult() == GameModel::ActionResult::Undone
        || m_model->lastResult() == GameModel::ActionResult::Redone) {
        // 撤销/重做：不切换回合，直接回到该玩家继续操作
        m_waiting = false;
        resetSelection();
        updateShipInfo();
        updateStatus();
        return;
    }
    // 人机模式：若轮到 AI（玩家2），自动代打
    if (m_aiOpponent && m_model->currentPlayer() == 1) {
        m_waiting = true;
        m_status->setText(QStringLiteral("AI 思考中…"));
        refreshButtons();
        m_aiTimer->start(900);
        return;
    }

    // 一个动作结束：先让当前玩家看清棋盘上的结果，短暂延迟后再切提示页
    m_waiting = true;
    m_status->setText(resultText(m_model->lastResult()));
    refreshButtons();
    m_handoffTimer->start(1600);
}

void MainWindow::onAiTurnTimeout()
{
    if (m_phase != Phase::Play)
        return;
    m_model->aiPlay();
    resetSelection();
    updateShipInfo();
}

void MainWindow::onSurrender()
{
    if (m_phase != Phase::Play || m_waiting)
        return;
    m_model->surrender();
    resetSelection();
    updateShipInfo();
}

void MainWindow::onHandoffTimeout()
{
    m_waiting = false;
    showPrompt(QStringLiteral("轮到 玩家%1").arg(m_model->currentPlayer() + 1),
               QStringLiteral("点击开始回合"),
               QStringLiteral("开始回合"),
               PromptRole::Turn);
}

void MainWindow::endGame(int winner)
{
    m_phase = Phase::Ended;
    m_obsTimer->stop();
    m_model->revealAll(); // 揭示最终棋盘（boardChanged 因 phase!=Play 不触发流程）
    m_boardFinal->setSnapshot(snapshotFromModel(*m_model, 0));
    m_endTitle->setText(QStringLiteral("玩家%1 获胜！").arg(winner + 1));
    m_stack->setCurrentWidget(m_endPage);
}

void MainWindow::onRestart()
{
    onStartClicked();
}

void MainWindow::onBackToMenu()
{
    m_phase = Phase::Menu;
    m_obsTimer->stop();
    m_stack->setCurrentWidget(m_menuPage);
    m_online = false;
}

// ---------------------------------------------------------------------------
// 联网对战
// ---------------------------------------------------------------------------

void MainWindow::onStartOnline()
{
    bool ok = false;
    const QString addr = QInputDialog::getText(this, QStringLiteral("在线对战"),
        QStringLiteral("输入服务器地址（主机:端口）"), QLineEdit::Normal,
        QStringLiteral("127.0.0.1:12345"), &ok).trimmed();
    if (!ok || addr.isEmpty())
        return;

    QString host = QStringLiteral("127.0.0.1");
    quint16 port = 0;
    const int colon = addr.lastIndexOf(QLatin1Char(':'));
    if (colon > 0) {
        host = addr.left(colon).trimmed();
        port = addr.mid(colon + 1).trimmed().toUShort();
    } else {
        port = addr.toUShort();
    }
    if (port == 0)
        return;

    m_online = true;
    m_aiOpponent = false;
    m_net = new NetSession(this);
    connect(m_net, &NetSession::updated, this, &MainWindow::onNetUpdated);
    m_net->connectTo(host, port);
    m_net->queue();

    m_status->setText(QStringLiteral("正在匹配，请稍候…"));
    m_stack->setCurrentWidget(m_gamePage);
}

void MainWindow::onNetUpdated()
{
    if (!m_online || !m_net)
        return;
    m_netState = m_net->state();

    if (m_net->gameOver()) {
        m_phase = Phase::Ended;
        m_boardFinal->setSnapshot(snapshotFromJson(m_netState));
        m_endTitle->setText(QStringLiteral("玩家%1 获胜！").arg(m_net->winner() + 1));
        m_stack->setCurrentWidget(m_endPage);
        return;
    }

    if (!m_net->matched())
        return; // 尚未匹配

    if (m_phase != Phase::Play) {
        m_phase = Phase::Play;
        m_waiting = false;
        m_viewPlayer = m_net->you();
        resetSelection();
        m_stack->setCurrentWidget(m_gamePage);
    }
    refreshBoard();
    updateStatus();
    refreshButtons();
}

void MainWindow::onCellClickedOnline(int r, int c)
{
    if (m_phase != Phase::Play || m_waiting)
        return;

    if (m_mode == Mode::Fog) {
        m_net->sendAction(QStringLiteral("reveal %1 %2").arg(r + 1).arg(c + 1));
        resetSelection();
        return;
    }

    if (m_mode == Mode::Attack) {
        if (m_selectedShip >= 0)
            m_net->sendAction(QStringLiteral("attack %1 %2 %3").arg(m_selectedShip).arg(r + 1).arg(c + 1));
        resetSelection();
        return;
    }

    // 选择己方战舰
    int idx = -1;
    for (const QJsonValue& v : m_netState[QStringLiteral("myShips")].toArray()) {
        const QJsonObject o = v.toObject();
        for (const QJsonValue& cc : o[QStringLiteral("cells")].toArray())
            if (cc.toArray()[0].toInt() == r && cc.toArray()[1].toInt() == c) { idx = o[QStringLiteral("index")].toInt(-1); break; }
        if (idx != -1)
            break;
    }
    m_selectedShip = idx;
    m_board->setSelectedShip(idx);
    m_board->setHighlightCells({});
    updateShipInfo();
}

// ---------------------------------------------------------------------------
// 棋盘交互
// ---------------------------------------------------------------------------

void MainWindow::onCellClicked(int r, int c)
{
    if (m_phase != Phase::Play || m_waiting)
        return;

    if (m_online) {
        onCellClickedOnline(r, c);
        return;
    }

    if (m_mode == Mode::Fog) {
        if (m_model->canReveal(r, c)) {
            m_model->revealCell(r, c);
            resetSelection();
            updateShipInfo();
        } else {
            m_status->setText(QStringLiteral("该格无法揭开（已揭示或越界）"));
        }
        return;
    }

    if (m_mode == Mode::Attack) {
        if (m_selectedShip >= 0 && m_model->canAttack(m_selectedShip, r, c)) {
            m_model->attackShip(m_selectedShip, r, c);
            resetSelection();
            updateShipInfo();
        } else {
            m_status->setText(QStringLiteral("请选择射程内已揭示的敌舰"));
        }
        return;
    }

    // 选择己方战舰
    int idx = m_model->shipAt(r, c);
    if (idx != -1 && m_model->ship(idx).owner == m_model->currentPlayer()
        && m_model->ship(idx).hp > 0) {
        m_selectedShip = idx;
    } else {
        m_selectedShip = -1;
    }
    m_board->setSelectedShip(m_selectedShip);
    m_board->setHighlightCells({});
    updateShipInfo();
}

void MainWindow::onFogAction()
{
    m_mode = Mode::Fog;
    m_selectedShip = -1;
    m_board->setSelectedShip(-1);
    m_board->setHighlightCells({});
    m_status->setText(QStringLiteral("解雾：点击一个被迷雾覆盖的格子"));
}

void MainWindow::onTurnLeft()
{
    if (m_online) {
        if (m_selectedShip >= 0) { m_net->sendAction(QStringLiteral("turn %1 0").arg(m_selectedShip)); resetSelection(); }
        else m_status->setText(QStringLiteral("请先选择己方战舰"));
        return;
    }
    if (m_selectedShip < 0) { m_status->setText(QStringLiteral("请先选择己方战舰")); return; }
    if (m_model->canTurn(m_selectedShip, false)) {
        m_model->turnShip(m_selectedShip, false);
        resetSelection();
        updateShipInfo();
    } else {
        m_status->setText(QStringLiteral("无法转向（越界或与其它舰重叠）"));
    }
}

void MainWindow::onTurnRight()
{
    if (m_online) {
        if (m_selectedShip >= 0) { m_net->sendAction(QStringLiteral("turn %1 1").arg(m_selectedShip)); resetSelection(); }
        else m_status->setText(QStringLiteral("请先选择己方战舰"));
        return;
    }
    if (m_selectedShip < 0) { m_status->setText(QStringLiteral("请先选择己方战舰")); return; }
    if (m_model->canTurn(m_selectedShip, true)) {
        m_model->turnShip(m_selectedShip, true);
        resetSelection();
        updateShipInfo();
    } else {
        m_status->setText(QStringLiteral("无法转向（越界或与其它舰重叠）"));
    }
}

void MainWindow::onMoveAction()
{
    if (m_online) {
        if (m_selectedShip >= 0) { m_net->sendAction(QStringLiteral("move %1").arg(m_selectedShip)); resetSelection(); }
        else m_status->setText(QStringLiteral("请先选择己方战舰"));
        return;
    }
    if (m_selectedShip < 0) { m_status->setText(QStringLiteral("请先选择己方战舰")); return; }
    if (m_model->canMove(m_selectedShip)) {
        m_model->moveShip(m_selectedShip);
        resetSelection();
        updateShipInfo();
    } else {
        m_status->setText(QStringLiteral("无法移动（前方越界或被挡住）"));
    }
}

void MainWindow::onAttackAction()
{
    if (m_online) {
        if (m_selectedShip < 0) { m_status->setText(QStringLiteral("请先选择己方战舰")); return; }
        m_mode = Mode::Attack;
        const BoardSnapshot snap = snapshotFromJson(m_netState);
        for (const ShipView& sv : snap.ships) {
            if (sv.mine && sv.index == m_selectedShip) {
                QVector<QPoint> targets;
                for (const QPoint& p : attackRangeCells(sv, snap.rows, snap.cols))
                    if (snap.view[p.x()][p.y()] == 3)
                        targets.append(p);
                m_board->setHighlightCells(targets);
                break;
            }
        }
        m_status->setText(QStringLiteral("攻击：点击射程内已揭示的敌舰"));
        return;
    }
    if (m_selectedShip < 0) { m_status->setText(QStringLiteral("请先选择己方战舰")); return; }

    m_mode = Mode::Attack;
    QVector<QPoint> targets;
    for (int r = 0; r < m_model->rows(); r++)
        for (int c = 0; c < m_model->cols(); c++)
            if (m_model->canAttack(m_selectedShip, r, c))
                targets.append(QPoint(r, c));
    m_board->setHighlightCells(targets);
    m_status->setText(QStringLiteral("攻击：点击射程内（≤%1 格）已揭示的敌舰")
                          .arg(m_model->attackRange(m_selectedShip)));
}

void MainWindow::onPassAction()
{
    if (m_online) { m_net->sendAction(QStringLiteral("pass")); resetSelection(); return; }
    m_model->passTurn();
    resetSelection();
    updateShipInfo();
}

void MainWindow::onUndo()
{
    if (m_online)
        return;
    if (m_phase != Phase::Play || m_waiting)
        return;
    if (!m_model->undo())
        m_status->setText(QStringLiteral("没有可撤销的操作。"));
}

void MainWindow::onRedo()
{
    if (m_online)
        return;
    if (m_phase != Phase::Play || m_waiting)
        return;
    if (!m_model->redo())
        m_status->setText(QStringLiteral("没有可重做的操作。"));
}

void MainWindow::onSaveReplay()
{
    if (m_online)
        return;
    const QString path = QFileDialog::getSaveFileName(this, QStringLiteral("保存复盘"),
        QString(), QStringLiteral("回放文件 (*.txt);;所有文件 (*)"));
    if (path.isEmpty())
        return;
    if (m_model->saveReplay(path))
        m_status->setText(QStringLiteral("已保存复盘到：%1").arg(path));
    else
        m_status->setText(QStringLiteral("保存复盘失败。"));
}

void MainWindow::onAiPlay()
{
    if (m_online)
        return;
    if (m_phase != Phase::Play || m_waiting)
        return;
    m_model->aiPlay();
    resetSelection();
    updateShipInfo();
}

// ---------------------------------------------------------------------------
// 辅助
// ---------------------------------------------------------------------------

void MainWindow::showPrompt(const QString& title, const QString& sub, const QString& btn, PromptRole role)
{
    m_promptTitle->setText(title);
    m_promptSub->setText(sub);
    m_promptBtn->setText(btn);
    m_promptRole = role;
    m_stack->setCurrentWidget(m_promptPage);
}

void MainWindow::resetSelection()
{
    m_mode = Mode::None;
    m_selectedShip = -1;
    m_board->setSelectedShip(-1);
    m_board->setHighlightCells({});
    m_board->setRangeCells({});
}

void MainWindow::refreshBoard()
{
    if (m_online && m_net)
        m_board->setSnapshot(snapshotFromJson(m_netState));
    else
        m_board->setSnapshot(snapshotFromModel(*m_model, m_viewPlayer));
}

void MainWindow::cancelSelection()
{
    if (m_phase != Phase::Play || m_waiting)
        return;
    resetSelection();
    updateShipInfo();
    updateStatus();
}

void MainWindow::updateStatus()
{
    if (m_online) {
        if (m_phase == Phase::Play) {
            const int cur = m_netState[QStringLiteral("currentPlayer")].toInt(0);
            m_status->setText((cur == m_net->you())
                                  ? QStringLiteral("你的回合")
                                  : QStringLiteral("等待对方…"));
        }
        return;
    }
    if (m_phase == Phase::Observe1 || m_phase == Phase::Observe2) {
        m_status->setText(QStringLiteral("玩家%1 观察阶段：请记住己方舰队与行/列提示").arg(m_viewPlayer + 1));
    } else if (m_phase == Phase::Play) {
        int myShips = 0, myHp = 0, enShips = 0, enHp = 0;
        for (int i = 0; i < m_model->shipCount(); i++) {
            const GameModel::Ship& s = m_model->ship(i);
            if (s.hp <= 0) continue;
            if (s.owner == m_model->currentPlayer()) { myShips++; myHp += s.hp; }
            else { enShips++; enHp += s.hp; }
        }
        m_status->setText(QStringLiteral("玩家%1 的回合 · 己方 %2 舰(血%3) · 敌方 %4 舰(血%5)")
                              .arg(m_model->currentPlayer() + 1)
                              .arg(myShips).arg(myHp)
                              .arg(enShips).arg(enHp));
    }
}

void MainWindow::updateShipInfo()
{
    if (m_online) {
        const BoardSnapshot snap = snapshotFromJson(m_netState);
        const ShipView* sel = nullptr;
        for (const ShipView& sv : snap.ships)
            if (sv.mine && sv.index == m_selectedShip) { sel = &sv; break; }
        if (sel) {
            static const QString dirNames[] = {
                QStringLiteral("北"), QStringLiteral("东"),
                QStringLiteral("南"), QStringLiteral("西")
            };
            m_shipInfo->setText(QStringLiteral("已选中：体积 %1 · 血量 %2/%3 · 射程 %4 · 船头朝%5")
                                    .arg(sel->size).arg(sel->hp).arg(sel->maxHp)
                                    .arg(sel->size * sel->size).arg(dirNames[sel->dir % 4]));
            m_board->setRangeCells(attackRangeCells(*sel, snap.rows, snap.cols));
        } else {
            m_shipInfo->setText(QStringLiteral("未选中战舰（点击己方战舰选择）"));
            m_board->setRangeCells({});
        }
        refreshButtons();
        return;
    }
    if (m_selectedShip >= 0 && m_selectedShip < m_model->shipCount()) {
        const GameModel::Ship& s = m_model->ship(m_selectedShip);
        static const QString dirNames[] = {
            QStringLiteral("北"), QStringLiteral("东"),
            QStringLiteral("南"), QStringLiteral("西")
        };
        m_shipInfo->setText(QStringLiteral("已选中：体积 %1 · 血量 %2/%3 · 射程 %4 · 船头朝%5")
                                .arg(s.size)
                                .arg(s.hp)
                                .arg(s.maxHp)
                                .arg(m_model->attackRange(m_selectedShip))
                                .arg(dirNames[s.dir % 4]));
        m_board->setRangeCells(m_model->attackRangeCells(m_selectedShip));
    } else {
        m_shipInfo->setText(QStringLiteral("未选中战舰（点击己方战舰选择）"));
        m_board->setRangeCells({});
    }
    refreshButtons();
}

void MainWindow::refreshButtons()
{
    bool play = (m_phase == Phase::Play) && !m_waiting;
    m_fogBtn->setEnabled(play);
    m_passBtn->setEnabled(play);
    m_aiBtn->setEnabled(play && !m_online);
    m_undoBtn->setEnabled(play && !m_online && m_model->undoCount() > 0);
    m_redoBtn->setEnabled(play && !m_online && m_model->redoCount() > 0);

    bool hasSel = play && m_selectedShip >= 0;
    m_turnLBtn->setEnabled(hasSel);
    m_turnRBtn->setEnabled(hasSel);
    m_moveBtn->setEnabled(hasSel);
    m_attackBtn->setEnabled(hasSel);

    bool obs = (m_phase == Phase::Observe1 || m_phase == Phase::Observe2);
    m_obsBanner->setVisible(obs);
    m_skipObsBtn->setVisible(obs);
}