#include "AppConfig.hpp"

#include <iostream>
#include <optional>
#include <cstdint>
#include <string>
#include <string_view>
#include <vector>

namespace
{
bool parseUint32(
    const char* text,
    uint32_t& value)
{
    uint32_t parsed = 0;
    bool hasDigit = false;

    for (int i = 0; text[i] != '\0'; ++i)
    {
        if (text[i] < '0' || text[i] > '9')
        {
            return false;
        }

        hasDigit = true;
        parsed = parsed * 10u +
            static_cast<uint32_t>(text[i] - '0');
    }

    if (!hasDigit)
    {
        return false;
    }

    value = parsed;
    return true;
}

bool parseFeedIndex(
    const char* text,
    uint32_t maxFeeds,
    uint32_t& index)
{
    uint32_t parsed = 0;

    if (!parseUint32(text, parsed) ||
        parsed >= maxFeeds)
    {
        return false;
    }

    index = parsed;
    return true;
}

bool parseGrid(
    std::string_view text,
    uint32_t& cols,
    uint32_t& rows)
{
    const size_t xPos = text.find('x');
    if (xPos == std::string_view::npos)
    {
        return false;
    }

    const std::string colText(text.substr(0, xPos));
    const std::string rowText(text.substr(xPos + 1));

    uint32_t parsedCols = 0;
    uint32_t parsedRows = 0;

    if (!parseUint32(colText.c_str(), parsedCols) ||
        !parseUint32(rowText.c_str(), parsedRows) ||
        parsedCols == 0 ||
        parsedRows == 0 ||
        parsedCols > MaxFeedCount / parsedRows)
    {
        return false;
    }

    cols = parsedCols;
    rows = parsedRows;
    return true;
}

uint32_t feedCount(const AppConfig& config)
{
    return config.gridCols * config.gridRows;
}

void applyDefaultFeeds(AppConfig& config)
{
    config.feeds.assign(feedCount(config), FeedConfig{});
}
}

std::optional<FeedKind> parseFeedKind(std::string_view text)
{
    if (text == "nosignal" ||
        text == "none" ||
        text == "fake")
    {
        return FeedKind::NoSignal;
    }

    if (text == "mxl")
    {
        return FeedKind::MxlPlaceholder;
    }

    if (text == "smpte")
    {
        return FeedKind::SmpteBars;
    }

    if (text == "mxlsdk")
    {
        return FeedKind::MxlSdk;
    }

    return std::nullopt;
}

std::optional<PresentModeConfig> parsePresentMode(std::string_view text)
{
    if (text == "fifo")
    {
        return PresentModeConfig::Fifo;
    }

    if (text == "mailbox")
    {
        return PresentModeConfig::Mailbox;
    }

    if (text == "immediate")
    {
        return PresentModeConfig::Immediate;
    }

    return std::nullopt;
}

std::string_view feedKindName(FeedKind kind)
{
    switch (kind)
    {
        case FeedKind::MxlPlaceholder:
            return "mxl";

        case FeedKind::SmpteBars:
            return "smpte";

        case FeedKind::MxlSdk:
            return "mxlsdk";

        case FeedKind::NoSignal:
        default:
            return "nosignal";
    }
}

void printUsage(const char* executableName)
{
    std::cout
        << "Usage: "
        << executableName
        << " [options] [feed...]\n"
        << "Options:\n"
        << "  --no-fps              Disable FPS logging\n"
        << "  --perf                Log per-frame CPU timing breakdown\n"
        << "  --verbose             Enable detailed startup and SDK logs\n"
        << "  --grid <cols>x<rows>  Set multiview grid (default 2x2, max 16 feeds)\n"
        << "  --fps-cap <fps>       Limit render loop FPS (default 60)\n"
        << "  --present <mode>      Present mode: fifo, mailbox, immediate (default mailbox)\n"
        << "  --feed <idx> <kind>   Set feed slot kind explicitly\n"
        << "  --domain <idx> <path> Set MXL domain for feed slot\n"
        << "  --flow <idx> <uuid>   Set MXL flow UUID for feed slot\n"
        << "  --version             Print version\n"
        << "  --help                Print this help\n"
        << "Feed kinds: nosignal, none, fake, mxl, smpte, mxlsdk\n"
        << "Default: 2x2 grid, all slots nosignal"
        << std::endl;
}

ConfigParseResult parseAppConfig(
    int argc,
    char* argv[])
{
    ConfigParseResult result;

    for (int i = 1; i < argc; ++i)
    {
        if (std::string_view(argv[i]) != "--grid")
        {
            continue;
        }

        if (i + 1 >= argc ||
            !parseGrid(
                argv[i + 1],
                result.config.gridCols,
                result.config.gridRows))
        {
            std::cerr << "--grid must be <cols>x<rows> with 1-"
                      << MaxFeedCount << " total feeds"
                      << std::endl;
            result.shouldExit = true;
            result.exitCode = 1;
            return result;
        }

        ++i;
    }

    applyDefaultFeeds(result.config);

    for (int i = 1; i < argc; ++i)
    {
        const std::string_view arg(argv[i]);

        if (arg == "--help" || arg == "-h")
        {
            printUsage(argv[0]);
            result.shouldExit = true;
            result.exitCode = 0;
            return result;
        }
    }

    for (int i = 1; i < argc; ++i)
    {
        const std::string_view arg(argv[i]);

        if (arg == "--version" || arg == "-v")
        {
            std::cout
                << AppName
                << " "
                << AppVersionMajor
                << "."
                << AppVersionMinor
                << "."
                << AppVersionPatch
                << std::endl;

            result.shouldExit = true;
            result.exitCode = 0;
            return result;
        }
    }

    std::vector<std::string_view> feedArgs;

    for (int i = 1; i < argc; ++i)
    {
        const std::string_view arg(argv[i]);

        if (arg == "--no-fps")
        {
            result.config.logFps = false;
            continue;
        }

        if (arg == "--perf")
        {
            result.config.logPerf = true;
            continue;
        }

        if (arg == "--verbose")
        {
            result.config.verbose = true;
            continue;
        }

        if (arg == "--grid")
        {
            ++i;
            continue;
        }

        if (arg == "--fps-cap")
        {
            if (i + 1 >= argc)
            {
                std::cerr << "--fps-cap requires <fps>"
                          << std::endl;
                result.shouldExit = true;
                result.exitCode = 1;
                return result;
            }

            uint32_t fpsCap = 0;

            if (!parseUint32(argv[i + 1], fpsCap) ||
                fpsCap == 0 || fpsCap > 240)
            {
                std::cerr << "--fps-cap must be 1-240"
                          << std::endl;
                result.shouldExit = true;
                result.exitCode = 1;
                return result;
            }

            result.config.fpsCap = fpsCap;
            ++i;
            continue;
        }

        if (arg == "--present")
        {
            if (i + 1 >= argc)
            {
                std::cerr << "--present requires <mode>"
                          << std::endl;
                result.shouldExit = true;
                result.exitCode = 1;
                return result;
            }

            const std::optional<PresentModeConfig> mode =
                parsePresentMode(argv[i + 1]);

            if (!mode.has_value())
            {
                std::cerr
                    << "--present must be fifo, mailbox, or immediate"
                    << std::endl;
                result.shouldExit = true;
                result.exitCode = 1;
                return result;
            }

            result.config.presentMode = mode.value();
            ++i;
            continue;
        }

        if (arg == "--feed")
        {
            if (i + 2 >= argc)
            {
                std::cerr << "--feed requires <index> <kind>"
                          << std::endl;
                result.shouldExit = true;
                result.exitCode = 1;
                return result;
            }

            uint32_t index = 0;
            if (!parseFeedIndex(
                    argv[i + 1],
                    feedCount(result.config),
                    index))
            {
                std::cerr << "--feed index must be 0-"
                          << (feedCount(result.config) - 1) << std::endl;
                result.shouldExit = true;
                result.exitCode = 1;
                return result;
            }

            const std::optional<FeedKind> kind =
                parseFeedKind(argv[i + 2]);

            if (!kind.has_value())
            {
                std::cerr << "Unknown feed kind: "
                          << argv[i + 2] << std::endl;
                printUsage(argv[0]);
                result.shouldExit = true;
                result.exitCode = 1;
                return result;
            }

            result.config.feeds[index].kind = kind.value();
            i += 2;
            continue;
        }

        if (arg == "--domain")
        {
            if (i + 2 >= argc)
            {
                std::cerr << "--domain requires <index> <path>"
                          << std::endl;
                result.shouldExit = true;
                result.exitCode = 1;
                return result;
            }

            uint32_t index = 0;
            if (!parseFeedIndex(
                    argv[i + 1],
                    feedCount(result.config),
                    index))
            {
                std::cerr << "--domain index must be 0-"
                          << (feedCount(result.config) - 1) << std::endl;
                result.shouldExit = true;
                result.exitCode = 1;
                return result;
            }

            result.config.feeds[index].mxlDomain =
                std::string(argv[i + 2]);

            i += 2;
            continue;
        }

        if (arg == "--flow")
        {
            if (i + 2 >= argc)
            {
                std::cerr << "--flow requires <index> <uuid>"
                          << std::endl;
                result.shouldExit = true;
                result.exitCode = 1;
                return result;
            }

            uint32_t index = 0;
            if (!parseFeedIndex(
                    argv[i + 1],
                    feedCount(result.config),
                    index))
            {
                std::cerr << "--flow index must be 0-"
                          << (feedCount(result.config) - 1) << std::endl;
                result.shouldExit = true;
                result.exitCode = 1;
                return result;
            }

            result.config.feeds[index].mxlFlowId =
                std::string(argv[i + 2]);
            result.config.feeds[index].kind =
                FeedKind::MxlSdk;

            i += 2;
            continue;
        }

        feedArgs.push_back(arg);
    }

    if (feedArgs.size() > result.config.feeds.size())
    {
        std::cerr << "Too many feed arguments" << std::endl;
        printUsage(argv[0]);
        result.shouldExit = true;
        result.exitCode = 1;
        return result;
    }

    size_t feedArgIndex = 0;

    for (uint32_t slot = 0;
         slot < result.config.feeds.size() && feedArgIndex < feedArgs.size();
         ++slot)
    {
        if (result.config.feeds[slot].kind == FeedKind::MxlSdk)
        {
            continue;
        }

        const std::optional<FeedKind> parsed =
            parseFeedKind(feedArgs[feedArgIndex]);

        if (!parsed.has_value())
        {
            std::cerr << "Unknown feed kind: "
                      << feedArgs[feedArgIndex] << std::endl;
            printUsage(argv[0]);
            result.shouldExit = true;
            result.exitCode = 1;
            return result;
        }

        result.config.feeds[slot].kind = parsed.value();
        ++feedArgIndex;
    }

    if (feedArgIndex < feedArgs.size())
    {
        std::cerr << "Too many feed arguments for available slots"
                  << std::endl;
        printUsage(argv[0]);
        result.shouldExit = true;
        result.exitCode = 1;
        return result;
    }

    return result;
}