using AutoRig.Analyze;

namespace AutoRig.Dl;

/// <summary>One downloadable artifact of a catalog model.</summary>
public sealed class DownloadFile
{
    public required string Url { get; init; }
    public required string FileName { get; init; }

    /// <summary>Bytes, 0 when unknown (progress shows bytes only).</summary>
    public long SizeBytes { get; init; }

    /// <summary>Hex SHA-256; empty = not pinned (verification skipped with a warning).</summary>
    public string Sha256 { get; init; } = "";
}

/// <summary>A deep-learning rigging model the library knows how to run.</summary>
public sealed class CatalogEntry
{
    public required string Id { get; init; }
    public required string Title { get; init; }
    public required string Summary { get; init; }
    public required string License { get; init; }
    public required string Attribution { get; init; }
    public required string HomepageUrl { get; init; }
    public required DownloadFile[] Files { get; init; }

    /// <summary>Which ported inference architecture runs this ("rignet").</summary>
    public required string Architecture { get; init; }

    /// <summary>False when the pure-C# runtime cannot execute this architecture yet
    /// (entry is visible in the catalog but locked: no download, no enable).</summary>
    public bool RuntimeSupported { get; init; } = true;

    /// <summary>Fixed memory the runtime needs regardless of the mesh.</summary>
    public required long BaseRamBytes { get; init; }

    /// <summary>Additional bytes per input vertex (analysis-proxy resolution).</summary>
    public required double RamPerVertexBytes { get; init; }

    public required OrganicCategory[] BestFor { get; init; }
}

/// <summary>
/// The curated model catalog (spec §7): models whose architectures this library has
/// ported. Grows deliberately - each entry is real, runnable inference, not a link.
/// Downloads always come from the model authors' official distribution; nothing is
/// redistributed by this library.
/// </summary>
public static class ModelCatalog
{
    public static readonly IReadOnlyList<CatalogEntry> Entries = new[]
    {
        new CatalogEntry
        {
            Id = "anymate_v1",
            Title = "Anymate",
            Summary = "Three-stage neural rigging trained on the Anymate dataset "
                + "(2025): joint prediction, connectivity classification, and NEURAL "
                + "skin weights - the full rig from three PointBERT models.",
            License = "Apache-2.0 (code and checkpoints)",
            Attribution = "Deng et al. - Anymate: A Dataset and Baselines for Learning "
                + "3D Object Rigging (2025). https://github.com/yfde/Anymate",
            HomepageUrl = "https://huggingface.co/yfdeng/Anymate",
            Files = new[]
            {
                new DownloadFile
                {
                    Url = "https://huggingface.co/yfdeng/Anymate/resolve/main/"
                        + "checkpoints/joint/bert-transformer_latent-train-8gpu-finetune.pth.tar",
                    FileName = "anymate_joint.pth.tar",
                    SizeBytes = 358_767_232,
                },
                new DownloadFile
                {
                    Url = "https://huggingface.co/yfdeng/Anymate/resolve/main/"
                        + "checkpoints/conn/bert-attendjoints_con_combine-train-8gpu-finetune.pth.tar",
                    FileName = "anymate_conn.pth.tar",
                    SizeBytes = 797_758_236,
                },
                new DownloadFile
                {
                    Url = "https://huggingface.co/yfdeng/Anymate/resolve/main/"
                        + "checkpoints/skin/bert-attendjoints_combine-train-8gpu-finetune.pth.tar",
                    FileName = "anymate_skin.pth.tar",
                    SizeBytes = 628_914_378,
                },
            },
            Architecture = "anymate-transformer",
            BaseRamBytes = 8L * 1024 * 1024 * 1024,
            RamPerVertexBytes = 120_000,
            BestFor = new[]
            {
                OrganicCategory.Humanoid, OrganicCategory.Quadruped,
                OrganicCategory.Winged, OrganicCategory.Other,
            },
        },
        new CatalogEntry
        {
            Id = "rignet_v1",
            Title = "RigNet",
            Summary = "Neural rigging for organic shapes (joints, hierarchy and skin weights), "
                + "trained on game character models. Xu et al., SIGGRAPH 2020.",
            License = "GPL-3.0 (code); trained models distributed by the authors",
            Attribution = "Zhan Xu, Yang Zhou, Evangelos Kalogerakis, Chris Landreth, Karan Singh - "
                + "RigNet: Neural Rigging for Articulated Characters (SIGGRAPH 2020). "
                + "https://github.com/zhan-xu/RigNet",
            HomepageUrl = "https://github.com/zhan-xu/RigNet",
            Files = new[]
            {
                new DownloadFile
                {
                    // Official checkpoint bundle from the authors' Google Drive
                    // (linked from the repository README).
                    Url = "https://drive.google.com/uc?export=download&id=1gM2Lerk7a2R0g9DwlK3IvCfp8c2aFVXs",
                    FileName = "rignet_checkpoints.zip",
                    SizeBytes = 0,
                },
            },
            Architecture = "rignet",
            BaseRamBytes = 2L * 1024 * 1024 * 1024,        // runtime + weights, generous
            RamPerVertexBytes = 220_000,                   // per proxy vertex (graph features + attention)
            BestFor = new[] { OrganicCategory.Humanoid, OrganicCategory.Quadruped, OrganicCategory.Other },
        },
        new CatalogEntry
        {
            Id = "unirig_v1",
            Title = "UniRig",
            Summary = "Transformer skeleton prediction trained on Articulation-XL "
                + "(SIGGRAPH 2025, VAST-AI/Tsinghua). Broad coverage across body plans. "
                + "Deterministic greedy decode; skin weights via geodesic skinning. "
                + "Heavy on CPU (~5 min per model).",
            License = "MIT (code); checkpoints distributed by the authors on Hugging Face",
            Attribution = "VAST-AI Research & Tsinghua University - One Model to Rig Them All: "
                + "Diverse Skeleton Rigging with UniRig (SIGGRAPH 2025). "
                + "https://github.com/VAST-AI-Research/UniRig",
            HomepageUrl = "https://huggingface.co/VAST-AI/UniRig",
            Files = new[]
            {
                // Real layout of the official repo (src/inference/download.py).
                new DownloadFile
                {
                    Url = "https://huggingface.co/VAST-AI/UniRig/resolve/main/skeleton/articulation-xl_quantization_256/model.ckpt",
                    FileName = "unirig_skeleton.ckpt",
                    SizeBytes = 0,
                },
                new DownloadFile
                {
                    Url = "https://huggingface.co/VAST-AI/UniRig/resolve/main/skin/articulation-xl/model.ckpt",
                    FileName = "unirig_skin.ckpt",
                    SizeBytes = 0,
                },
            },
            Architecture = "unirig-transformer",
            RuntimeSupported = true,    // ported + golden-verified + corpus gate green
            BaseRamBytes = 6L * 1024 * 1024 * 1024,
            RamPerVertexBytes = 150_000,
            BestFor = new[]
            {
                OrganicCategory.Humanoid, OrganicCategory.Quadruped,
                OrganicCategory.Winged, OrganicCategory.Other,
            },
        },
        new CatalogEntry
        {
            Id = "riganything_v1",
            Title = "RigAnything",
            Summary = "Template-free autoregressive DIFFUSION rigging with NEURAL "
                + "skin weights (SIGGRAPH TOG 2025). Strong on non-standard body "
                + "plans; stochastic sampling (seeded here). Fastest of the family.",
            License = "ADOBE RESEARCH LICENSE: NONCOMMERCIAL research/teaching use "
                + "ONLY. Do not use for commercial projects.",
            Attribution = "Liu et al. - RigAnything: Template-Free Autoregressive Rigging "
                + "for Diverse 3D Assets (SIGGRAPH TOG 2025). "
                + "https://github.com/Isabella98Liu/RigAnything",
            HomepageUrl = "https://github.com/Isabella98Liu/RigAnything",
            Files = new[]
            {
                new DownloadFile
                {
                    Url = "https://huggingface.co/Isabellaliu/RigAnything/resolve/main/riganything_ckpt.pt",
                    FileName = "riganything_ckpt.pt",
                    SizeBytes = 2_344_595_770,
                },
            },
            Architecture = "riganything-transformer",
            RuntimeSupported = true,
            BaseRamBytes = 6L * 1024 * 1024 * 1024,
            RamPerVertexBytes = 150_000,
            BestFor = new[]
            {
                OrganicCategory.Humanoid, OrganicCategory.Quadruped,
                OrganicCategory.Winged, OrganicCategory.Other,
            },
        },
        new CatalogEntry
        {
            Id = "puppeteer_v1",
            Title = "Puppeteer",
            Summary = "Skeleton generation with parent indices carried in the token "
                + "sequence, diverse-pose training (ByteDance Seed3D, 2025). NEURAL "
                + "skin weights via its skinning transformer (PartField features). "
                + "Deterministic greedy decode.",
            License = "See authors' repository; checkpoints on Hugging Face",
            Attribution = "ByteDance Seed3D - Puppeteer (skeleton generation and "
                + "skinning-weight prediction). https://huggingface.co/Seed3D/Puppeteer",
            HomepageUrl = "https://huggingface.co/Seed3D/Puppeteer",
            Files = new[]
            {
                new DownloadFile
                {
                    Url = "https://huggingface.co/Seed3D/Puppeteer/resolve/main/"
                        + "skeleton_ckpts/puppeteer_skeleton_w_diverse_pose.pth",
                    FileName = "puppeteer_skeleton.pth",
                    SizeBytes = 4_399_390_278,
                },
                new DownloadFile
                {
                    Url = "https://huggingface.co/Seed3D/Puppeteer/resolve/main/"
                        + "skinning_ckpts/puppeteer_skin_w_diverse_pose_depth1.pth",
                    FileName = "puppeteer_skin.pth",
                    SizeBytes = 1_701_065_999,
                },
            },
            Architecture = "puppeteer-transformer",
            RuntimeSupported = true,
            BaseRamBytes = 6L * 1024 * 1024 * 1024,
            RamPerVertexBytes = 150_000,
            BestFor = new[]
            {
                OrganicCategory.Humanoid, OrganicCategory.Quadruped,
                OrganicCategory.Winged, OrganicCategory.Other,
            },
        },
        new CatalogEntry
        {
            Id = "magicarticulate_v1",
            Title = "MagicArticulate",
            Summary = "Autoregressive articulation model learned from Articulation-XL "
                + "(ByteDance Seed3D, 2025; Apache-2.0 code). Skeleton-only: skin "
                + "weights via geodesic skinning. Deterministic greedy decode, and "
                + "the fastest transformer of the family (~1 min per model).",
            License = "Code Apache-2.0; checkpoints on Hugging Face",
            Attribution = "MagicArticulate: Make Your 3D Models Articulation-Ready (2025). "
                + "https://github.com/Seed3D/MagicArticulate",
            HomepageUrl = "https://github.com/Seed3D/MagicArticulate",
            Files = new[]
            {
                new DownloadFile
                {
                    Url = "https://huggingface.co/Seed3D/MagicArticulate/resolve/main/"
                        + "skeleton_ckpt/checkpoint_trainonv2_hier.pth",
                    FileName = "magicarticulate_hier.pth",
                    SizeBytes = 4_400_581_006,
                },
            },
            Architecture = "magicarticulate-transformer",
            RuntimeSupported = true,
            BaseRamBytes = 6L * 1024 * 1024 * 1024,
            RamPerVertexBytes = 150_000,
            BestFor = new[]
            {
                OrganicCategory.Humanoid, OrganicCategory.Quadruped,
                OrganicCategory.Winged, OrganicCategory.Other,
            },
        },
        new CatalogEntry
        {
            Id = "skintokens_v1",
            Title = "SkinTokens (TokenRig)",
            Summary = "UniRig's successor: skeleton + skin weights generated as one "
                + "token sequence (FSQ-CVAE skin tokens, RL-refined; VAST-AI 2026). "
                + "Deterministic greedy decode with NEURAL skin weights decoded by "
                + "the FSQ skin-VAE. Heaviest on CPU (~10+ min per model).",
            License = "See authors' repository; checkpoints distributed by the authors",
            Attribution = "VAST-AI Research - SkinTokens: A Learned Compact Representation "
                + "for Unified Autoregressive Rigging (2026). "
                + "https://github.com/VAST-AI-Research/SkinTokens",
            HomepageUrl = "https://github.com/VAST-AI-Research/SkinTokens",
            Files = new[]
            {
                new DownloadFile
                {
                    Url = "https://huggingface.co/VAST-AI/SkinTokens/resolve/main/"
                        + "experiments/articulation_xl_quantization_256_token_4/grpo_1400.ckpt",
                    FileName = "skintokens_grpo_1400.ckpt",
                    SizeBytes = 1_131_603_979,
                },
            },
            Architecture = "skintokens-transformer",
            RuntimeSupported = true,
            BaseRamBytes = 6L * 1024 * 1024 * 1024,
            RamPerVertexBytes = 150_000,
            BestFor = new[]
            {
                OrganicCategory.Humanoid, OrganicCategory.Quadruped,
                OrganicCategory.Winged, OrganicCategory.Other,
            },
        },
    };

    /// <summary>Entry lookup by id, null when unknown.</summary>
    public static CatalogEntry Find( string id )
        => Entries.FirstOrDefault( e => e.Id == id );
}