#include <algorithm>
#include <cstdio>
#include <exception>
#include <filesystem>
#include <fstream>
#include <optional>
#include <string>
#include <string_view>
#include <vector>

import ra3;

namespace {
    auto print_usage() -> void {
        std::puts("OpenRA3 - headless Red Alert 3 reconstruction");
        std::puts("usage:");
        std::puts("  openra3 maps [--game-dir DIR]");
        std::puts("  openra3 skirmish [--game-dir DIR] [--map ID] [--frames N] [--seed N]");
        std::puts("  openra3 render [--game-dir DIR] [--map ID] [--frames N] [--seed N] [--world-size S] [--out FILE.bmp]");
        std::puts("env: RA3_GAME_DIR (default C:\\Red Alert 3); game data is never copied into the repo");
    }

    auto option_value(const std::vector<std::string> &args, std::string_view name) -> std::optional<std::string> {
        for (std::size_t i = 0; i + 1U < args.size(); ++i) {
            if (args[i] == name) return args[i + 1U];
        }
        return std::nullopt;
    }

    /** Build `<dir>/Data/<name>` portably (avoids path/char[] ambiguity). */
    auto data_path(const std::filesystem::path &dir, std::string_view name) -> std::filesystem::path {
        return dir / std::string{"Data"} / std::string{name};
    }

    auto command_maps(const std::optional<std::filesystem::path> &game_dir) -> int {
        const auto dir = ra3::fs::find_game_dir(game_dir);
        if (!dir) {
            std::puts("no Red Alert 3 install found; pass --game-dir or set RA3_GAME_DIR");
            return 1;
        }
        const auto archive_path = data_path(*dir, "MapsMultiplayer.big");
        const auto archive = ra3::fs::big_archive::open(archive_path);
        const auto catalog = ra3::map::map_catalog::from_archive(archive);
        const auto name = archive_path.filename().string();
        std::printf("maps in %s: %zu\n", name.c_str(), catalog.size());
        for (const auto &entry: catalog.maps()) {
            std::printf("  %-28s %6u KB packed / %6u KB unpacked\n", entry.id.c_str(), entry.stored_size / 1024U, entry.unpacked_size / 1024U);
        }
        return 0;
    }

    auto command_skirmish(const std::vector<std::string> &args, const std::optional<std::filesystem::path> &game_dir) -> int {
        ra3::skirmish::match_config config;
        std::vector<ra3::map::start_position> starts;
        std::string source = "builtin";

        const auto requested_map = option_value(args, "--map");
        if (const auto dir = ra3::fs::find_game_dir(game_dir)) {
            try {
                const auto archive = ra3::fs::big_archive::open(data_path(*dir, "MapsMultiplayer.big"));
                const auto catalog = ra3::map::map_catalog::from_archive(archive);
                const ra3::map::map_info *info = nullptr;
                if (requested_map) {
                    info = catalog.find(*requested_map);
                    if (info == nullptr) std::printf("map '%s' not found; falling back\n", requested_map->c_str());
                } else if (catalog.size() > 0U) {
                    info = &catalog.maps().front();
                }
                if (info != nullptr) {
                    const auto loaded = ra3::map::load_map(archive, *info);
                    starts = loaded.starts;
                    config.map_id = info->id;
                    source = "archive:" + info->id;
                }
            } catch (const std::exception &error) {
                std::printf("map load failed: %s\n", error.what());
            }
        }

        if (starts.size() < 2U) {
            starts = ra3::skirmish::builtin_start_positions();
            source = "builtin";
        }
        if (const auto seed = option_value(args, "--seed")) config.seed = static_cast<ra3::core::uint32>(std::stoul(*seed));
        if (const auto frames = option_value(args, "--frames")) config.max_frames = static_cast<ra3::core::uint32>(std::stoul(*frames));

        auto match = ra3::skirmish::skirmish_match::create(config, starts);
        const auto summary = match.run();

        std::printf("OpenRA3 skirmish  map=%s  source=%s  seed=%u\n", config.map_id.c_str(), source.c_str(), config.seed);
        std::puts("start positions:");
        for (std::size_t i = 0; i < starts.size(); ++i) {
            std::printf("  P%zu (%.0f, %.0f)\n", i, static_cast<double>(starts[i].x), static_cast<double>(starts[i].y));
        }
        std::printf("result: %s  winner=%d  frames=%u (%.1f s)\n", summary.decided ? "decided" : "timeout", summary.winner, summary.frames,
                    static_cast<double>(summary.frames) / 30.0);
        for (const auto &player: match.players()) {
            const auto side = std::string{ra3::game::to_string(player.side)};
            std::printf("  P%u %-10s %-7s money=%6d units=%2zu kills=%d losses=%d\n", player.index, player.name.c_str(), side.c_str(), player.money,
                        match.unit_count(player.index), player.kills, player.losses);
        }
        return 0;
    }

    /** Entry name of a map's overview art (`<stem>_art.tga`). */
    auto art_entry_for(const ra3::map::map_info &info) -> std::string {
        auto entry = info.entry;
        if (entry.size() > 4U) entry.resize(entry.size() - 4U);
        entry += "_art.tga";
        return entry;
    }

    auto command_render(const std::vector<std::string> &args, const std::optional<std::filesystem::path> &game_dir) -> int {
        const auto dir = ra3::fs::find_game_dir(game_dir);
        if (!dir) {
            std::puts("no Red Alert 3 install found; pass --game-dir or set RA3_GAME_DIR");
            return 1;
        }

        const auto archive = ra3::fs::big_archive::open(data_path(*dir, "MapsMultiplayer.big"));
        const auto catalog = ra3::map::map_catalog::from_archive(archive);
        const auto requested = option_value(args, "--map");
        const ra3::map::map_info *info = nullptr;
        if (requested) {
            info = catalog.find(*requested);
        } else if (catalog.size() > 0U) {
            info = &catalog.maps().front();
        }
        if (info == nullptr) {
            std::printf("map '%s' not found\n", requested ? requested->c_str() : "");
            return 1;
        }

        const auto tga = archive.read(art_entry_for(*info), true);
        const auto art = ra3::render::decode_tga(tga);

        ra3::render::scene_options scene;
        scene.title = "OpenRA3 - " + info->id;
        if (const auto size = option_value(args, "--world-size")) scene.world_width = scene.world_height = std::stod(*size);

        ra3::skirmish::match_config config;
        config.map_id = info->id;
        if (const auto seed = option_value(args, "--seed")) config.seed = static_cast<ra3::core::uint32>(std::stoul(*seed));
        if (const auto frames = option_value(args, "--frames")) config.max_frames = static_cast<ra3::core::uint32>(std::stoul(*frames));

        auto starts = ra3::map::load_map(archive, *info).starts;
        if (starts.size() < 2U) starts = ra3::skirmish::builtin_start_positions();
        auto match = ra3::skirmish::skirmish_match::create(config, starts);
        const auto summary = match.run();

        std::vector<ra3::render::marker> markers;
        for (const auto &player: match.players()) {
            markers.push_back({static_cast<double>(player.start.x), static_cast<double>(player.start.y), ra3::render::yellow, 6});
        }
        for (const auto &entry: match.units()) {
            if (!entry.alive) continue;
            const auto color = entry.owner == 0U ? ra3::render::blue : ra3::render::red;
            int radius = 2;
            if (entry.cls == ra3::skirmish::unit_class::tank) radius = 4;
            if (entry.cls == ra3::skirmish::unit_class::base) radius = 6;
            markers.push_back({static_cast<double>(entry.position.x), static_cast<double>(entry.position.y), color, radius});
        }

        const auto composed = ra3::render::compose(art, markers, scene);

        const auto out = option_value(args, "--out");
        const bool no_window = std::find(args.begin(), args.end(), "--no-window") != args.end();
        bool shown = false;
        if (!out && !no_window) {
            ra3::ui::viewer_options viewer;
            viewer.title = scene.title;
            shown = ra3::ui::run_viewer(composed, viewer);
        }
        if (!shown) {
            const auto path = out.value_or("openra3_view.bmp");
            const auto bmp = ra3::render::encode_bmp(composed);
            std::ofstream file(path, std::ios::binary);
            if (!file) {
                std::printf("cannot write %s\n", path.c_str());
                return 1;
            }
            file.write(reinterpret_cast<const char *>(bmp.data()), static_cast<std::streamsize>(bmp.size()));
            std::printf("wrote %s (%ux%u)\n", path.c_str(), composed.width(), composed.height());
        }

        std::printf("map=%s  units P0=%d P1=%d  winner=%d  frames=%u\n", info->id.c_str(), summary.units_left[0], summary.units_left[1], summary.winner,
                    summary.frames);
        return 0;
    }
}

auto main(int argc, char **argv) -> int {
    const std::vector<std::string> args{argv + 1, argv + argc};
    if (args.empty()) {
        print_usage();
        return 0;
    }

    const auto command = args[0];
    const std::vector<std::string> rest{args.begin() + 1, args.end()};

    std::optional<std::filesystem::path> game_dir;
    if (const auto dir = option_value(rest, "--game-dir")) game_dir = *dir;

    if (command == "maps") return command_maps(game_dir);
    if (command == "skirmish") return command_skirmish(rest, game_dir);
    if (command == "render") return command_render(rest, game_dir);
    if (command == "help" || command == "--help" || command == "-h") {
        print_usage();
        return 0;
    }

    print_usage();
    return 2;
}