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; } = "";

    // ── 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";

    /// <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;
                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);
    }
}