// Assets/_Project/Scripts/Gameplay/EnemyAbilities/EnemyAbilityPool.cs
using System;
using UnityEngine;
using TD.Core;

namespace TD.Gameplay.EnemyAbilities
{
    /// <summary>
    /// Scene singleton holding every <see cref="EnemyAbilityDefinition"/> available this match,
    /// authored as a flat array in the inspector for convenience. Internally it builds a
    /// fixed-size table indexed by <see cref="EnemyAbilityKind"/> so lookups are a single array
    /// access, not a scan. Mirrors <see cref="BuilderSpells.BuilderSpellPool"/> exactly.
    /// </summary>
    /// <remarks>
    /// Plain MonoBehaviour: identical on every peer (same assets), so there is nothing to sync.
    /// Only the server calls <see cref="RollRandom"/> (at enemy spawn time, in
    /// <c>WaveManager.SpawnEnemy</c>).
    /// </remarks>
    public class EnemyAbilityPool : MonoBehaviour
    {
        public static EnemyAbilityPool Instance { get; private set; }

        [Tooltip("Every EnemyAbilityDefinition asset available this match. One entry per " +
                 "EnemyAbilityKind — order doesn't matter, Kind on the asset itself decides " +
                 "its slot.")]
        [SerializeField] private EnemyAbilityDefinition[] abilities;

        [Tooltip("Relative weight of an enemy rolling no ability at all, vs. the combined " +
                 "weight of every entry in 'abilities'. Higher = abilities are rarer.")]
        [Min(0f)]
        [SerializeField] private float noAbilityWeight = 20f;

        // Fixed-size, enum-indexed lookup built once in Awake. Sized to the enum's entry count,
        // not authored count, so an out-of-range Kind is a compile-time impossibility rather
        // than a bounds check we'd otherwise need on every Get().
        private EnemyAbilityDefinition[] byKind;

        private void Awake()
        {
            if (Instance != null && Instance != this)
            {
                Debug.LogError("[EnemyAbilityPool] Multiple instances detected. Only one per scene.");
                return;
            }
            Instance = this;

            int kindCount = Enum.GetValues(typeof(EnemyAbilityKind)).Length;
            byKind = new EnemyAbilityDefinition[kindCount];
            if (abilities == null) return;

            for (int i = 0; i < abilities.Length; i++)
            {
                var def = abilities[i];
                if (def == null) continue;
                byKind[(int)def.Kind] = def;
            }
        }

        private void OnDestroy()
        {
            if (Instance == this) Instance = null;
        }

        /// <summary>Returns the ability asset for <paramref name="kind"/>, or null if none is
        /// authored in this pool.</summary>
        public EnemyAbilityDefinition Get(EnemyAbilityKind kind)
        {
            int i = (int)kind;
            return (byKind != null && i >= 0 && i < byKind.Length) ? byKind[i] : null;
        }

        /// <summary>
        /// Server-only: weighted random draw across every authored ability plus the
        /// no-ability bucket. Returns null when "no ability" is drawn, or when the pool has
        /// nothing authored.
        /// </summary>
        public EnemyAbilityDefinition RollRandom()
        {
            if (abilities == null || abilities.Length == 0) return null;

            float total = noAbilityWeight;
            for (int i = 0; i < abilities.Length; i++)
                if (abilities[i] != null) total += abilities[i].Weight;

            if (total <= 0f) return null;

            float roll = UnityEngine.Random.Range(0f, total);
            if (roll < noAbilityWeight) return null;
            roll -= noAbilityWeight;

            for (int i = 0; i < abilities.Length; i++)
            {
                var def = abilities[i];
                if (def == null) continue;
                if (roll < def.Weight) return def;
                roll -= def.Weight;
            }

            return null;
        }
    }
}