main.cpp

// main：组装 core / log / render / input 四模块，驱动游戏主循环。
//
//  用法：
//    snake [宽度 高度]          玩游戏（默认 20 20，日志追加写入 snake.log）
//    snake --replay '<日志行>'  回放模式：解析日志行并渲染终局 CLI 画面，
//                              最下行显示反转后的日志行（不写文件）
//
//  主循环：poll(333ms) → request_turn → tick → on_tick → draw；
//  每帧把当前日志行（GameLogger::pending 的序列化结果）经
//  IRenderer::set_status_line 交给渲染器，反转后显示在最下方一行；
//  局末 finish() 把完整日志行追加写入 snake.log。
//
// 模块约束：main 是唯一允许同时包含 log / render / input 的单元
// （见 DESIGN.md §1），三模块之间不互相包含。

#include "core/game_state.hpp"
#include "input/input_handler.hpp"
#include "log/logger.hpp"
#include "render/renderer.hpp"

#include <chrono>
#include <cstdint>
#include <deque>
#include <exception>
#include <iostream>
#include <optional>
#include <random>
#include <string>
#include <string_view>

namespace {

// 日志 1 基「行×列」坐标 → 核心 0 基坐标（GameLogger 内部换算的逆）。
// Args:
//   p: 日志域坐标（x=列, y=行，1 基）。
// Returns: 核心坐标（x=列, y=行，0 基）。
snake::core::Position FromLogCoord(snake::core::Position p) {
    return {p.x - 1, p.y - 1};
}

// 解析命令行参数 [宽度 高度]；缺失时取默认值 20 20。
// Args:
//   argc/argv: 命令行参数。
//   width/height: 输出解析后的棋盘尺寸。
// Returns: 解析成功返回 true；参数个数或取值非法时返回 false。
bool ParseArgs(int argc, char** argv, std::int32_t& width, std::int32_t& height) {
    if (argc == 1) {
        width = 20;
        height = 20;
        return true;
    }
    if (argc != 3) return false;
    try {
        const int w = std::stoi(argv[1]);
        const int h = std::stoi(argv[2]);
        if (w < 1 || h < 1) return false;
        width = w;
        height = h;
        return true;
    } catch (const std::exception&) {
        return false;
    }
}

// 由日志条目重建终局画面（迷你回放）：沿方向流推进蛇身，按果实序列切换果实。
// Args:
//   entry: 已解析的日志条目（坐标域：1 基行×列）。
//   body: 输出——回放结束后的蛇身（front 为头，core 0 基坐标）。
//   fruit: 输出——回放结束后的果实（core 0 基坐标，可能不存在）。
void ReplayToFrame(const snake::log::LogEntry& entry,
                   std::deque<snake::core::Position>& body,
                   std::optional<snake::core::Position>& fruit) {
    body.clear();
    body.push_back(FromLogCoord(entry.initial_head));
    std::size_t fruit_idx = 0;
    if (!entry.fruits.empty()) fruit = FromLogCoord(entry.fruits[0]);
    for (snake::core::Direction d : entry.moves) {
        const snake::core::Position next = body.front().advanced(d);
        // 越界：日志与棋盘矛盾（或该步即撞墙），停止回放，保留当前画面。
        if (next.x < 0 || next.x >= entry.board_width ||
            next.y < 0 || next.y >= entry.board_height) {
            break;
        }
        const bool eats = fruit && *fruit == next;
        body.push_front(next);
        if (eats) {
            ++fruit_idx;
            fruit.reset();
            if (fruit_idx < entry.fruits.size()) {
                fruit = FromLogCoord(entry.fruits[fruit_idx]);
            }
        } else {
            body.pop_back();
        }
    }
}

// 回放模式入口：解析日志行并渲染终局 CLI 画面。
// Args:
//   line: 单行日志文本。
// Returns: 进程退出码（0 成功，2 日志非法）。
int RunReplay(const char* line) {
    auto parsed = snake::log::LogEntry::deserialize(line);
    if (!parsed) {
        std::cerr << "replay: " << snake::log::to_string(parsed.error()) << '\n';
        return 2;
    }
    std::deque<snake::core::Position> body;
    std::optional<snake::core::Position> fruit;
    ReplayToFrame(*parsed, body, fruit);
    snake::render::IRenderer* renderer = snake::render::make_renderer();
    renderer->invalidate();
    renderer->draw_static(parsed->board_width, parsed->board_height,
                          body, fruit, line);
    return 0;
}

}  // namespace

int main(int argc, char** argv) {
    // 回放模式：snake --replay '<日志行>'
    if (argc == 3 && std::string_view(argv[1]) == "--replay") {
        return RunReplay(argv[2]);
    }

    std::int32_t width = 0, height = 0;
    if (!ParseArgs(argc, argv, width, height)) {
        std::cerr << "usage: snake [width height]\n";
        return 2;
    }

    snake::input::TermiosGuard tty;  // 原始模式；stdin 非 tty 时自动降级为空操作
    auto* input    = snake::input::make_input_handler();
    auto* renderer = snake::render::make_renderer();

    std::random_device rd;
    snake::core::GameState game(width, height, rd());

    snake::log::GameLogger logger;
    // 传核心 0 基坐标；GameLogger 内部换算为日志 1 基「行×列」。
    logger.begin(width, height, game.snake().head(), game.fruit().position());

    // 初始帧：进入游戏立即显示棋盘与状态行（无输入时画面保持静止）。
    renderer->invalidate();
    renderer->set_status_line(logger.pending().serialize());
    renderer->draw(game);

    // 250ms 识别窗口 ≈ 4 Hz：长按时每个窗口识别一次，短按一次识别一次；
    // 窗口内无输入则返回 nullopt——蛇不移动、日志不变（需求 2）。
    constexpr auto kWindow = std::chrono::milliseconds(250);
    while (!input->quit_requested()) {
        if (auto cmd = input->poll(kWindow); cmd) {
            if (input->quit_requested()) break;
            // 180° 转向请求会被 Snake::turn 忽略，但该次按压仍视为一次识别。
            game.request_turn(cmd->direction);
            const snake::core::TickResult r = game.tick();
            logger.on_tick(r);
            renderer->set_status_line(logger.pending().serialize());
            renderer->draw(game);
            if (game.phase() != snake::core::Phase::Running) {
                renderer->draw_game_over(game);
                try {
                    logger.finish(game.phase(), "snake.log");
                } catch (const std::exception& e) {
                    std::cerr << "warning: " << e.what() << '\n';
                }
                break;
            }
        }
    }
    // 提前退出（q / EOF）而未终局：仍以 {L} 结局落盘，保证每局都有日志。
    if (game.phase() == snake::core::Phase::Running) {
        try {
            logger.finish(game.phase(), "snake.log");
        } catch (const std::exception& e) {
            std::cerr << "warning: " << e.what() << '\n';
        }
    }
    return 0;
}