using Godot;
using System.Collections.Generic;
using Theriapolis.Core.Data;
using Theriapolis.GodotHost.Platform;

namespace Theriapolis.GodotHost.UI;

/// <summary>
/// In-progress character record. Resource (not Node) per
/// GODOT_PORTING_GUIDE.md §2.1: serializable via ResourceSaver.save,
/// inspectable in the editor, doesn't need tree presence.
///
/// Mirrors <c>app.jsx</c>'s <c>state</c> shape — clade/species/class/etc.,
/// stat assignment, chosen skills, name. Mutate via <see cref="Patch"/> so
/// every change emits <see cref="Changed"/>; the Aside and Wizard listen
/// and re-render on that single signal.
/// </summary>
[GlobalClass]
public partial class CharacterDraft : Resource
{
    // NB: Resource defines its own `Changed` signal (emitted via EmitChanged()).
    // We piggyback on it instead of declaring our own to avoid a name clash —
    // listeners do `draft.Changed += ...` exactly the same way either way.

    [Export] public string CladeId      { get; set; } = "";
    [Export] public string SpeciesId    { get; set; } = "";
    [Export] public string ClassId      { get; set; } = "";
    [Export] public string SubclassId   { get; set; } = "";
    [Export] public string BackgroundId { get; set; } = "";

    /// <summary>"male" or "female". Required for every character. For
    /// purebreds with sex-axis variants (Elk, Lion), drives variant
    /// resolution. For hybrids, sire variant always resolves to "male"
    /// and dam variant to "female" by parent-role definition — the
    /// character's own Sex remains an identity field.</summary>
    [Export] public string Sex { get; set; } = "";

    /// <summary>Lineage-axis variant id picked for the purebred species
    /// (e.g. "sheep" or "goat" for Ram-Folk). Empty if the picked species
    /// has no lineage variant.</summary>
    [Export] public string SpeciesVariant { get; set; } = "";

    /// <summary>Hybrid: lineage-axis variant for sire's species.</summary>
    [Export] public string SireSpeciesVariant { get; set; } = "";
    /// <summary>Hybrid: lineage-axis variant for dam's species.</summary>
    [Export] public string DamSpeciesVariant  { get; set; } = "";

    // ── Phase 6.5 hybrid origin ────────────────────────────────────────
    /// <summary>True when the PC is a hybrid (two parent lineages).</summary>
    [Export] public bool IsHybrid { get; set; }
    [Export] public string SireCladeId   { get; set; } = "";
    [Export] public string SireSpeciesId { get; set; } = "";
    [Export] public string DamCladeId    { get; set; } = "";
    [Export] public string DamSpeciesId  { get; set; } = "";
    /// <summary>"sire" or "dam" — which parent the PC presents as.</summary>
    [Export] public string DominantParent { get; set; } = "sire";

    // Per theriapolis-rpg-clades.md "Building a Hybrid", simplified:
    // hybrids take ONE ability modifier from each parent Clade. The
    // original no-stack rule (take +1 + free elsewhere on overlap) was
    // dropped — overlapping picks just sum.
    /// <summary>Ability key picked from sire's clade mods (e.g. "STR").</summary>
    [Export] public string SireChosenAbility { get; set; } = "";
    /// <summary>Ability key picked from dam's clade mods.</summary>
    [Export] public string DamChosenAbility { get; set; } = "";

    // Phase B trait pickers, per theriapolis-rpg-clades.md "Building a Hybrid":
    //   Clade traits: 2 from dominant parent + 1 from non-dominant (player's
    //                 split). Detriments are inherited fully from both clades
    //                 — no pick.
    //   Species trait: 1 per parent.
    //   Species detriment: 1 per parent.
    /// <summary>Clade trait IDs picked from sire's clade. Length depends on
    /// dominant: 2 if sire is dominant, 1 if dam is.</summary>
    [Export] public Godot.Collections.Array<string> SireChosenCladeTraits { get; set; } = new();
    [Export] public Godot.Collections.Array<string> DamChosenCladeTraits  { get; set; } = new();
    [Export] public string SireChosenSpeciesTrait     { get; set; } = "";
    [Export] public string DamChosenSpeciesTrait      { get; set; } = "";
    [Export] public string SireChosenSpeciesDetriment { get; set; } = "";
    [Export] public string DamChosenSpeciesDetriment  { get; set; } = "";

    /// <summary>Number of clade traits the named lineage is allowed to pick:
    /// 2 if it's the dominant parent, 1 otherwise.</summary>
    public int CladeTraitLimit(string lineage) =>
        lineage == DominantParent ? 2 : 1;

    /// <summary>
    /// Resolves the active variant id for a species. <paramref name="role"/>
    /// is "" for purebred, "sire" or "dam" for hybrid lineages. Returns
    /// empty when the species has no variants or the relevant pick/sex is
    /// missing.
    /// </summary>
    public string ResolveVariantId(Theriapolis.Core.Data.SpeciesDef? species, string role)
    {
        if (species is null || string.IsNullOrEmpty(species.VariantAxis)) return "";
        return species.VariantAxis switch
        {
            // Sex-axis: purebred uses character Sex; hybrid lineages are
            // pinned by parent role (sire = male, dam = female).
            "sex" => role switch
            {
                "sire" => "male",
                "dam"  => "female",
                _      => Sex,
            },
            // Lineage-axis: explicit per-species pick.
            "lineage" => role switch
            {
                "sire" => SireSpeciesVariant,
                "dam"  => DamSpeciesVariant,
                _      => SpeciesVariant,
            },
            _ => "",
        };
    }

    /// <summary>
    /// Resolves the "active" clade for downstream steps (Class / Subclass
    /// / Background). Purebred uses <see cref="CladeId"/>; hybrids use
    /// the dominant parent's clade.
    /// </summary>
    public string EffectiveCladeId => IsHybrid
        ? (DominantParent == "sire" ? SireCladeId : DamCladeId)
        : CladeId;

    /// <summary>Same logic as <see cref="EffectiveCladeId"/>, for species.</summary>
    public string EffectiveSpeciesId => IsHybrid
        ? (DominantParent == "sire" ? SireSpeciesId : DamSpeciesId)
        : SpeciesId;

    /// <summary>True iff the character includes <paramref name="cladeId"/>
    /// in its lineage. Purebred matches CladeId; hybrid matches if either
    /// Sire or Dam clade equals the id (case-insensitive).</summary>
    public bool HasClade(string cladeId)
    {
        if (string.IsNullOrEmpty(cladeId)) return false;
        if (IsHybrid)
            return string.Equals(SireCladeId, cladeId, System.StringComparison.OrdinalIgnoreCase)
                || string.Equals(DamCladeId,  cladeId, System.StringComparison.OrdinalIgnoreCase);
        return string.Equals(CladeId, cladeId, System.StringComparison.OrdinalIgnoreCase);
    }

    /// <summary>True iff any clade in the character's lineage has the
    /// given <paramref name="kind"/> ("predator" or "prey").</summary>
    public bool HasAnyCladeOfKind(string kind)
    {
        if (IsHybrid)
        {
            return CodexContent.Clade(SireCladeId)?.Kind == kind
                || CodexContent.Clade(DamCladeId)?.Kind == kind;
        }
        return CodexContent.Clade(CladeId)?.Kind == kind;
    }

    /// <summary>"array" or "roll" — assignment method for ability scores.</summary>
    [Export] public string StatMethod  { get; set; } = "array";
    [Export] public Godot.Collections.Array<int> StatPool { get; set; }
        = new() { 15, 14, 13, 12, 10, 8 };
    [Export] public Godot.Collections.Dictionary StatAssign { get; set; } = new();

    [Export] public Godot.Collections.Array<string> ChosenSkills { get; set; } = new();
    [Export] public string CharacterName { get; set; } = "";

    /// <summary>
    /// Mutate one or more fields, then emit Changed once. Mirrors
    /// the JS prototype's <c>set(patch)</c> from app.jsx.
    /// </summary>
    public void Patch(Godot.Collections.Dictionary patch)
    {
        foreach (var key in patch.Keys)
        {
            string k = (string)key;
            switch (k)
            {
                case "clade_id":         CladeId = (string)patch[key]; break;
                case "species_id":       SpeciesId = (string)patch[key]; break;
                case "class_id":         ClassId = (string)patch[key]; break;
                case "subclass_id":      SubclassId = (string)patch[key]; break;
                case "background_id":    BackgroundId = (string)patch[key]; break;
                case "stat_method":      StatMethod = (string)patch[key]; break;
                case "stat_pool":        StatPool = (Godot.Collections.Array<int>)patch[key]; break;
                case "stat_assign":      StatAssign = (Godot.Collections.Dictionary)patch[key]; break;
                case "chosen_skills":    ChosenSkills = (Godot.Collections.Array<string>)patch[key]; break;
                case "character_name":   CharacterName = (string)patch[key]; break;
                case "is_hybrid":            IsHybrid = (bool)patch[key]; break;
                case "sire_clade_id":        SireCladeId = (string)patch[key]; break;
                case "sire_species_id":      SireSpeciesId = (string)patch[key]; break;
                case "dam_clade_id":         DamCladeId = (string)patch[key]; break;
                case "dam_species_id":       DamSpeciesId = (string)patch[key]; break;
                case "dominant_parent":      DominantParent = (string)patch[key]; break;
                case "sire_chosen_ability":  SireChosenAbility = (string)patch[key]; break;
                case "dam_chosen_ability":   DamChosenAbility = (string)patch[key]; break;
                case "sire_chosen_clade_traits":     SireChosenCladeTraits = (Godot.Collections.Array<string>)patch[key]; break;
                case "dam_chosen_clade_traits":      DamChosenCladeTraits = (Godot.Collections.Array<string>)patch[key]; break;
                case "sire_chosen_species_trait":    SireChosenSpeciesTrait = (string)patch[key]; break;
                case "dam_chosen_species_trait":     DamChosenSpeciesTrait = (string)patch[key]; break;
                case "sire_chosen_species_detriment":SireChosenSpeciesDetriment = (string)patch[key]; break;
                case "dam_chosen_species_detriment": DamChosenSpeciesDetriment = (string)patch[key]; break;
                case "sex":                     Sex = (string)patch[key]; break;
                case "species_variant":         SpeciesVariant = (string)patch[key]; break;
                case "sire_species_variant":    SireSpeciesVariant = (string)patch[key]; break;
                case "dam_species_variant":     DamSpeciesVariant = (string)patch[key]; break;
                default:
                    GD.PushWarning($"[CharacterDraft] unknown patch key: {k}");
                    break;
            }
        }
        EmitChanged();
    }
}

/// <summary>
/// Lazy-loaded immutable content tables. Replaces the React prototype's
/// data.jsx + autoload Content per GODOT_PORTING_GUIDE.md §2.2 — same
/// purpose, idiomatic C#.
/// </summary>
public static class CodexContent
{
    private static CladeDef[]? _clades;
    private static SpeciesDef[]? _species;
    private static ClassDef[]? _classes;
    private static SubclassDef[]? _subclasses;
    private static BackgroundDef[]? _backgrounds;

    public static CladeDef[] Clades            => _clades       ??= Load(l => l.LoadClades());
    public static SpeciesDef[] Species         => _species      ??= Load(l => l.LoadSpecies(Clades));
    public static ClassDef[] Classes           => _classes      ??= Load(l => l.LoadClasses());
    public static SubclassDef[] Subclasses     => _subclasses   ??= Load(l => l.LoadSubclasses(Classes));
    public static BackgroundDef[] Backgrounds  => _backgrounds  ??= Load(l => l.LoadBackgrounds());

    public static CladeDef? Clade(string id) => System.Array.Find(Clades, c => c.Id == id);
    public static SpeciesDef? SpeciesById(string id) => System.Array.Find(Species, s => s.Id == id);
    public static ClassDef? Class(string id) => System.Array.Find(Classes, c => c.Id == id);
    public static BackgroundDef? Background(string id) => System.Array.Find(Backgrounds, b => b.Id == id);

    public static IEnumerable<SpeciesDef> SpeciesOfClade(string cladeId)
    {
        foreach (var s in Species)
            if (string.Equals(s.CladeId, cladeId, System.StringComparison.OrdinalIgnoreCase))
                yield return s;
    }

    private static T Load<T>(System.Func<Theriapolis.Core.Data.ContentLoader, T> fn)
    {
        var loader = new Theriapolis.Core.Data.ContentLoader(ContentPaths.DataDir);
        return fn(loader);
    }
}