// Assets/_Project/Scripts/Gameplay/Waves/PhaseDefinition.cs
using System.Collections.Generic;
using UnityEngine;

namespace TD.Gameplay.Waves
{
    /// <summary>
    /// One phase of a run: the pool its cycle waves are drawn from, and the pool its boss is
    /// drawn from. A phase runs the same drawn wave set for every one of its cycles, then ends
    /// in a boss.
    /// </summary>
    /// <remarks>
    /// <b>Groups, not waves.</b> Both pools are lists of <see cref="WaveGroup"/> assets rather
    /// than flat wave lists, so re-balancing a run means dragging a group between phases instead
    /// of re-authoring individual entries. Listing the same group in two phases is legal — the
    /// draws are independent.
    ///
    /// <para><b>Draw contract.</b> <c>RunState</c> draws <c>WavesPerCycle</c> waves from
    /// <see cref="WaveGroups"/> with <b>distinct enemy types</b>, because enemy upgrades are keyed
    /// to a wave slot and two slots sharing an enemy type would make "which wave did this buff
    /// apply to" ambiguous. That makes the real authoring requirement stricter than the entry
    /// count: a phase needs at least <c>WavesPerCycle</c> distinct enemy types across its groups,
    /// not just that many waves. <see cref="CountDistinctEnemyTypes"/> exists so the draw can
    /// fail loudly at match start rather than mid-run.</para>
    /// </remarks>
    [CreateAssetMenu(fileName = "PhaseDefinition", menuName = "TD/Run/Phase Definition", order = 11)]
    public class PhaseDefinition : ScriptableObject
    {
        [Tooltip("Designer-facing name for this phase, shown in validation messages. " +
                 "Falls back to the asset name when empty.")]
        public string DisplayName;

        [Tooltip("Groups this phase's cycle waves are drawn from. All groups are pooled " +
                 "together for the draw; group membership is an authoring convenience, not a " +
                 "draw boundary.")]
        public WaveGroup[] WaveGroups;

        [Tooltip("Groups this phase's boss is drawn from. A boss is an ordinary WaveDefinition " +
                 "that happens to spawn a single powerful enemy.")]
        public WaveGroup[] BossGroups;

        [Tooltip("Enemy-buff cards votable during this phase. Gating is per PHASE, not per cycle " +
                 "— every card listed here can be voted on from this phase's very first wave. " +
                 "Cards must also appear in the scene's EnemyUpgradePool to be offerable.")]
        public EnemyUpgrades.EnemyUpgradeGroup[] EnemyUpgradeGroups;

        /// <summary>Name used in validation and log messages. Falls back to the asset name.</summary>
        public string Label => string.IsNullOrWhiteSpace(DisplayName) ? name : DisplayName;

        /// <summary>
        /// Appends every non-null, non-zero-weight entry across <paramref name="groups"/> into
        /// <paramref name="into"/>. Zero-weight entries are filtered here (not at draw time) so
        /// "weight 0 means it can never appear" is enforced in exactly one place.
        /// </summary>
        public static void CollectCandidates(WaveGroup[] groups, List<WavePoolEntry> into)
        {
            into.Clear();
            if (groups == null) return;

            for (int g = 0; g < groups.Length; g++)
            {
                var group = groups[g];
                if (group?.Waves == null) continue;

                for (int i = 0; i < group.Waves.Length; i++)
                {
                    var entry = group.Waves[i];
                    if (entry?.Wave == null) continue;
                    if (entry.Weight <= 0f) continue;
                    into.Add(entry);
                }
            }
        }

        /// <summary>Collects this phase's cycle-wave candidates.</summary>
        public void CollectWaveCandidates(List<WavePoolEntry> into)
            => CollectCandidates(WaveGroups, into);

        /// <summary>Collects this phase's boss candidates.</summary>
        public void CollectBossCandidates(List<WavePoolEntry> into)
            => CollectCandidates(BossGroups, into);

        /// <summary>
        /// How many distinct enemy types are reachable across this phase's wave groups. The
        /// upper bound on how many wave slots this phase can fill, since the draw requires
        /// distinct types.
        /// </summary>
        public int CountDistinctEnemyTypes()
        {
            var candidates = new List<WavePoolEntry>();
            CollectWaveCandidates(candidates);

            var seen = new HashSet<EnemyDefinition>();
            foreach (var entry in candidates)
            {
                var type = entry.Wave.PrimaryEnemyType;
                if (type != null) seen.Add(type);
            }
            return seen.Count;
        }
    }
}