#include <iostream>
#include <memory>
#include <algorithm>
#include <atomic>
#include <filesystem>
#include "CLI11.hpp"
#include "Companion.h"
#ifdef PM64_SUPPORT
#include "factories/pm64/AudioPreview.h"
#endif
#ifdef BK64_SUPPORT
#include "factories/bk64/ConfigFactory.h"
#endif

Companion* Companion::Instance;

#if defined(STANDALONE) && !defined(__EMSCRIPTEN__)

#ifdef BUILD_UI
#include "imgui.h"
#include "ui/BaseBackend.h"
#include "ui/View.h"
#include "ui/list/Main.h"
#include "ui/backends/LusBackend.h"
#include "ui/audio/SequenceDriver.h"
#ifdef PM64_SUPPORT
#include "factories/pm64/ShapeFactory.h"
#endif

static void LaunchUI() {
    if (Companion::Instance == nullptr) {
        std::cout << "No ROM loaded; nothing to display." << std::endl;
        return;
    }

    auto backend = UI::CreateLusBackend();
    UI::SetBackend(backend.get());

    auto views = std::make_shared<ViewManager>();
    views->SetView(std::make_shared<MainView>());

    // The backend owns the window + frame loop; returns when the user quits.
    backend->RunViewer(views);

    UI::SetBackend(nullptr);
}

// Default (no-subcommand) flow: list any ROMs in the cwd and ask the user to pick
// one or type a path. Returns the chosen path, or empty if nothing was given.
static std::string PromptForRom() {
    namespace fs = std::filesystem;
    std::vector<std::string> found;
    std::error_code ec;
    for (const auto& entry : fs::directory_iterator(fs::current_path(), ec)) {
        if (!entry.is_regular_file()) {
            continue;
        }
        std::string ext = entry.path().extension().string();
        std::transform(ext.begin(), ext.end(), ext.begin(), [](unsigned char c) { return (char)std::tolower(c); });
        if (ext == ".z64" || ext == ".n64" || ext == ".v64") {
            found.push_back(entry.path().filename().string());
        }
    }
    std::sort(found.begin(), found.end());

    if (!found.empty()) {
        std::cout << "ROMs in this directory:" << std::endl;
        for (size_t i = 0; i < found.size(); ++i) {
            std::cout << "  [" << i << "] " << found[i] << std::endl;
        }
        std::cout << "Select a ROM by number, or type a path [0]: " << std::flush;
    } else {
        std::cout << "Enter the path to a ROM: " << std::flush;
    }

    std::string line;
    if (!std::getline(std::cin, line)) {
        return {};
    }
    const auto first = line.find_first_not_of(" \t\r\n");
    const auto last = line.find_last_not_of(" \t\r\n");
    line = first == std::string::npos ? std::string() : line.substr(first, last - first + 1);

    if (line.empty()) {
        return found.empty() ? std::string() : found.front();
    }
    // A bare number selects from the list; anything else is treated as a path.
    if (!found.empty() && line.find_first_not_of("0123456789") == std::string::npos) {
        const size_t idx = std::stoul(line);
        if (idx < found.size()) {
            return found[idx];
        }
    }
    return line;
}
#endif

int main(int argc, char* argv[]) {
    CLI::App app{ "Torch - [T]orch is [O]ur [R]esource [C]onversion [H]elper\n\
        * It extracts from a baserom and generates code or an otr.\n\
        * It can also generate an otr from a folder of assets.\n" };
    std::string mode;
    std::string filename;
    std::string target;
    std::string folder;
    std::string archive;
    std::string version;
    std::string singlePath;
    ArchiveType otrMode = ArchiveType::None;
    bool otrModeSelected = false;
    bool xmlMode = false;
    bool debug = false;
    std::string srcdir;
    std::string destdir;
    std::vector<std::string> additionalFiles;

    app.require_subcommand();

    /* Generate an OTR */
    const auto otr = app.add_subcommand("otr", "OTR - Generates an otr\n");

    otr->add_option("<baserom.z64>", filename, "")->required()->check(CLI::ExistingFile);
    otr->add_flag("-v,--verbose", debug, "Verbose Debug Mode");
    otr->add_option("-s,--srcdir", srcdir,
                    "Set source directory to locate config.yml and asset metadata for processing")
        ->check(CLI::ExistingDirectory);
    otr->add_option("-d,--destdir", destdir, "Set destination directory for export");
    otr->add_option("-S,--single", singlePath,
                    "Extracts 1 yml rather than everything relative to the source directory");

    otr->parse_complete_callback([&] {
        const auto instance = Companion::Instance = new Companion(filename, ArchiveType::OTR, debug, srcdir, destdir);
        if (!singlePath.empty()) {
            instance->SetSingleYMLPath(singlePath);
        }
        instance->Init(ExportType::Binary);
    });

    /* Generate an O2R */
    const auto o2r = app.add_subcommand("o2r", "O2R - Generates an o2r\n");

    o2r->add_option("<baserom.z64>", filename, "")->required()->check(CLI::ExistingFile);
    o2r->add_flag("-v,--verbose", debug, "Verbose Debug Mode");
    o2r->add_option("-s,--srcdir", srcdir,
                    "Set source directory to locate config.yml and asset metadata for processing")
        ->check(CLI::ExistingDirectory);
    o2r->add_option("-d,--destdir", destdir, "Set destination directory for export");
    o2r->add_option("-a,--additional-files", additionalFiles,
                    "Additional files to include in the o2r archive (e.g., mods.toml)")
        ->check(CLI::ExistingFile);
    o2r->add_option("-u,--version", version, "Version to set in the o2r archive");
    o2r->add_option("-S,--single", singlePath,
                    "Extracts 1 yml rather than everything relative to the source directory");

    o2r->parse_complete_callback([&] {
        const auto instance = Companion::Instance = new Companion(filename, ArchiveType::O2R, debug, srcdir, destdir);
        instance->SetAdditionalFiles(additionalFiles);
        instance->SetVersion(version);
        if (!singlePath.empty()) {
            instance->SetSingleYMLPath(singlePath);
        }
        instance->Init(ExportType::Binary);
    });

    /* Generate C code */
    const auto code = app.add_subcommand("code", "Code - Generates C code\n");

    code->add_option("<baserom.z64>", filename, "")->required()->check(CLI::ExistingFile);
    code->add_flag("-v,--verbose", debug, "Verbose Debug Mode; adds offsets to C code");
    code->add_option("-s,--srcdir", srcdir,
                     "Set source directory to locate config.yml and asset metadata for processing")
        ->check(CLI::ExistingDirectory);
    code->add_option("-d,--destdir", destdir, "Set destination directory to place C code to");
    code->add_option("-S,--single", singlePath,
                     "Extracts 1 yml rather than everything relative to the source directory");

    code->parse_complete_callback([&]() {
        const auto instance = Companion::Instance = new Companion(filename, ArchiveType::None, debug, srcdir, destdir);
        if (!singlePath.empty()) {
            instance->SetSingleYMLPath(singlePath);
        }
        instance->Init(ExportType::Code);
    });

    /* Generate a binary */
    const auto binary = app.add_subcommand("binary", "Binary - Generates a binary\n");

    binary->add_option("<baserom.z64>", filename, "")->required()->check(CLI::ExistingFile);
    binary
        ->add_option("-s,--srcdir", srcdir,
                     "Set source directory to locate config.yml and asset metadata for processing")
        ->check(CLI::ExistingDirectory);
    binary->add_option("-d,--destdir", destdir, "Set destination directory to place binary to");

    binary->parse_complete_callback([&] {
        const auto instance = Companion::Instance = new Companion(filename, ArchiveType::None, debug, srcdir, destdir);
        instance->Init(ExportType::Binary);
    });

    /* Generate headers */
    const auto header = app.add_subcommand("header", "Header - Generates headers only\n");

    header->add_option("<baserom.z64>", filename, "")->required()->check(CLI::ExistingFile);
    header->add_flag("-o,--otr", otrModeSelected, "OTR/O2R Mode");
    header
        ->add_option("-s,--srcdir", srcdir,
                     "Set source directory to locate config.yml and asset metadata for processing")
        ->check(CLI::ExistingDirectory);
    header->add_option("-d,--destdir", destdir, "Set destination directory to place headers to");

    header->parse_complete_callback([&] {
        if (otrModeSelected) {
            otrMode = ArchiveType::OTR;
        } else {
            otrMode = ArchiveType::None;
        }

        const auto instance = Companion::Instance = new Companion(filename, otrMode, debug, srcdir, destdir);
        instance->Init(ExportType::Header);
    });

    /* Pack an archive from a folder */
    const auto pack = app.add_subcommand("pack", "Pack - Packs an archive from a folder\n");

    pack->add_option("<folder>", folder, "Generate OTR from a directory of assets")
        ->required()
        ->check(CLI::ExistingDirectory);
    pack->add_option("<target>", target, "Archive output destination")->required();
    pack->add_option("<archive-type>", archive, "Archive type: otr or o2r")->required();
    pack->add_option("-u,--version", version, "Version to set in the o2r archive");

    pack->parse_complete_callback([&] {
        if (archive == "otr") {
            otrMode = ArchiveType::OTR;
        } else if (archive == "o2r") {
            otrMode = ArchiveType::O2R;
        } else {
            std::cout << "Invalid archive type" << std::endl;
        }

        if (!folder.empty()) {
            Companion::Pack(folder, target, otrMode, version);
        } else {
            std::cout << "The folder is empty" << std::endl;
        }
    });

#ifdef BK64_SUPPORT
    /* Emit per-slot SHA-1s of the BK64 asset table */
    std::string hashesOut;
    const auto hashes =
        app.add_subcommand("hashes", "Hashes - Emit per-slot SHA-1 of BK64 asset table for v1.0 baseline\n");

    hashes->add_option("<baserom.z64>", filename, "")->required()->check(CLI::ExistingFile);
    hashes->add_option("-o,--output", hashesOut, "Output yaml path (default: hashes.yaml in cwd)");

    hashes->parse_complete_callback([&] {
        const std::filesystem::path outPath = hashesOut.empty() ? "hashes.yaml" : hashesOut;
        BK64::EmitAssetHashes(filename, outPath);
    });
#endif

    /* Generate modding files */
    const auto modding_root = app.add_subcommand("modding", "Modding - Generates modding files like png\n");
    const auto modding_import =
        modding_root->add_subcommand("import", "Import - Import modified files to generate C code\n");
    const auto modding_export = modding_root->add_subcommand("export", "Export - Export modified files to a folder\n");

    modding_import->add_option("mode", mode, "code, otr, o2r or header")->required();
    modding_import->add_option("<baserom.z64>", filename, "")->required()->check(CLI::ExistingFile);
    modding_import->add_flag("-v,--verbose", debug, "Verbose Debug Mode");
    modding_import
        ->add_option(
            "-s,--srcdir", srcdir,
            "Set source directory to locate config.yml and asset metadata for processing, including modified files")
        ->check(CLI::ExistingDirectory);
    modding_import->add_option("-d,--destdir", destdir, "Set destination directory to place for generating C code");

    modding_import->parse_complete_callback([&] {
        ArchiveType otrMode;

        if (mode == "otr") {
            otrMode = ArchiveType::OTR;
        } else if (mode == "o2r") {
            otrMode = ArchiveType::O2R;
        } else {
            otrMode = ArchiveType::None;
        }

        const auto instance = Companion::Instance = new Companion(filename, otrMode, debug, true, srcdir, destdir);
        if (mode == "code") {
            instance->Init(ExportType::Code);
        } else if (mode == "otr" || mode == "o2r") {
            instance->Init(ExportType::Binary);
        } else if (mode == "header") {
            instance->Init(ExportType::Header);
        } else {
            std::cout << "Invalid mode" << std::endl;
        }
    });

    modding_export->add_flag("-x,--xml", xmlMode, "XML Mode");
    modding_export->add_option("<baserom.z64>", filename, "")->required()->check(CLI::ExistingFile);
    modding_export
        ->add_option(
            "-s,--srcdir", srcdir,
            "Set source directory to locate config.yml and asset metadata for processing, including modified files")
        ->check(CLI::ExistingDirectory);
    modding_export->add_option("-d,--destdir", destdir,
                               "Set destination directory to place for generating modified files");

    modding_export->parse_complete_callback([&] {
        const auto instance = Companion::Instance = new Companion(filename, ArchiveType::None, debug, srcdir, destdir);
        if (xmlMode) {
            instance->Init(ExportType::XML);
        } else {
            instance->Init(ExportType::Modding);
        }
    });

#ifdef BUILD_UI
    /* Launch the interactive viewer */
    const auto ui = app.add_subcommand("ui", "UI - Parses a baserom and opens the interactive asset viewer\n");

    ui->add_option("<baserom.z64>", filename, "")->required()->check(CLI::ExistingFile);
    ui->add_flag("-v,--verbose", debug, "Verbose Debug Mode");
    ui->add_option("-s,--srcdir", srcdir, "Set source directory to locate config.yml and asset metadata for processing")
        ->check(CLI::ExistingDirectory);

    ui->parse_complete_callback([&] {
        const auto instance = Companion::Instance = new Companion(filename, ArchiveType::None, debug, srcdir, destdir);
#ifdef PM64_SUPPORT
        PM64Audio::SetPreviewAssets(true);
#endif
        // Parse-only: populate the asset results for the viewer without exporting
        // anything (shouldProcess = false skips all writes). Export type is
        // irrelevant since nothing is exported.
        std::atomic<size_t> assetCount{ 0 };
        instance->Init(ExportType::Binary, assetCount, false);
        if (std::getenv("TORCH_PM64_TEST") != nullptr) { // headless shape walk, no window
#ifdef PM64_SUPPORT
            for (const auto& [file, results] : instance->GetParseResults()) {
                for (const auto& item : results) {
                    if (item.type != "PM64:SHAPE") {
                        continue;
                    }
                    if (const char* filter = std::getenv("TORCH_SEQ_FILTER");
                        filter != nullptr && item.name.find(filter) == std::string::npos) {
                        continue;
                    }
                    PM64ShapeDebugBuild(item);
                }
            }
#endif
            return;
        }
        if (std::getenv("TORCH_SEQ_TEST") != nullptr) { // headless driver check, no window
            for (const auto& [file, results] : instance->GetParseResults()) {
                for (const auto& item : results) {
                    if (UI::GetSequenceDriver(item.type) == nullptr || !item.data.has_value()) {
                        continue;
                    }
                    if (const char* filter = std::getenv("TORCH_SEQ_FILTER");
                        filter != nullptr && item.name.find(filter) == std::string::npos) {
                        continue;
                    }
                    auto* driver = UI::GetSequenceDriver(item.type);
                    if (driver == nullptr) {
                        continue;
                    }
                    UI::RenderedAudio out;
                    const bool ok = driver->Render(item, 0, out);
                    float peak = 0.0f;
                    double sumSq = 0.0;
                    size_t loud = 0;
                    for (const auto v : out.pcm) {
                        const float f = std::fabs((float)v) / 32768.0f;
                        peak = std::max(peak, f);
                        sumSq += (double)f * f;
                        loud += f > 0.01f ? 1 : 0;
                    }
                    const double rms = out.pcm.empty() ? 0.0 : std::sqrt(sumSq / (double)out.pcm.size());
                    printf("[seqtest] %s ok=%d notes=%zu frames=%zu peak=%.3f rms=%.4f loud=%.1f%%\n",
                           item.name.c_str(), ok, out.noteCount, out.pcm.size() / 2, peak, rms,
                           out.pcm.empty() ? 0.0 : 100.0 * (double)loud / (double)out.pcm.size());
                    if (const char* wavDir = std::getenv("TORCH_SEQ_WAV")) {
                        std::string base = item.name;
                        std::replace(base.begin(), base.end(), '/', '_');
                        const std::string wavPath = std::string(wavDir) + "/" + base + ".wav";
                        FILE* f = fopen(wavPath.c_str(), "wb");
                        if (f != nullptr) {
                            const uint32_t dataSize = (uint32_t)(out.pcm.size() * 2);
                            const uint32_t riffSize = 36 + dataSize;
                            const uint32_t rate = 32000, byteRate = rate * 4;
                            const uint16_t fmt = 1, ch = 2, align = 4, bits = 16;
                            const uint32_t fmtSize = 16;
                            fwrite("RIFF", 1, 4, f);
                            fwrite(&riffSize, 4, 1, f);
                            fwrite("WAVE", 1, 4, f);
                            fwrite("fmt ", 1, 4, f);
                            fwrite(&fmtSize, 4, 1, f);
                            fwrite(&fmt, 2, 1, f);
                            fwrite(&ch, 2, 1, f);
                            fwrite(&rate, 4, 1, f);
                            fwrite(&byteRate, 4, 1, f);
                            fwrite(&align, 2, 1, f);
                            fwrite(&bits, 2, 1, f);
                            fwrite("data", 1, 4, f);
                            fwrite(&dataSize, 4, 1, f);
                            fwrite(out.pcm.data(), 2, out.pcm.size(), f);
                            fclose(f);
                        }
                    }
                }
            }
            return;
        }
        LaunchUI();
    });
#endif

#ifdef BUILD_UI
    // Default behavior with no subcommand: if the cwd looks like a project (has a
    // config.yml), open the viewer and prompt for a ROM instead of printing help.
    if (argc == 1 && std::filesystem::exists("config.yml")) {
        const std::string rom = PromptForRom();
        if (rom.empty()) {
            std::cout << app.help() << std::endl;
            return 0;
        }
        if (!std::filesystem::exists(rom)) {
            std::cout << "ROM not found: " << rom << std::endl;
            return 1;
        }
        Companion::Instance = new Companion(rom, ArchiveType::None, false, "", "");
#ifdef PM64_SUPPORT
        PM64Audio::SetPreviewAssets(true);
#endif
        std::atomic<size_t> assetCount{ 0 };
        Companion::Instance->Init(ExportType::Binary, assetCount, false);
        LaunchUI();
        return 0;
    }
#endif

    try {
        app.parse(argc, argv);
    } catch (const CLI::ParseError& e) {
        std::cout << app.help() << std::endl;
        return app.exit(e);
    }

    // No arguments --> display help.
    if (argc == 1) {
        std::cout << app.help() << std::endl;
    }

    return 0;
}
#endif