using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;

namespace ProjectI.Enemies
{
    public enum EnemyDirectorTier { Normal, Elite }
    public enum EnemySelectionMode { SingleType, Template, Procedural }

    [CreateAssetMenu(menuName = "ProjectI/Enemies/Director (provisional tuning)")]
    public sealed class EnemyDirectorDefinition : ScriptableObject
    {
        [Serializable]
        public struct Eligibility
        {
            [Min(0)] public int minimumStage, maximumStage;
            [Min(0)] public double minimumMinutes, maximumMinutes, minimumDifficulty, maximumDifficulty;
            [Range(0, 4)] public int minimumParticipants, maximumParticipants;
            public bool Valid => minimumStage >= 0 && maximumStage >= 0 && Ordered(minimumStage, maximumStage)
                && Ordered(minimumMinutes, maximumMinutes) && Ordered(minimumDifficulty, maximumDifficulty)
                && minimumParticipants >= 0 && minimumParticipants <= 4 && maximumParticipants <= 4 && Ordered(minimumParticipants, maximumParticipants);
            private static bool Ordered(double min, double max) => Finite(min) && Finite(max) && min >= 0 && max >= 0 && (max == 0 || max >= min);
            public bool Allows(int stage, double minutes, double difficulty, int participants) => Valid
                && Within(stage, minimumStage, maximumStage) && Within(minutes, minimumMinutes, maximumMinutes)
                && Within(difficulty, minimumDifficulty, maximumDifficulty) && Within(participants, minimumParticipants, maximumParticipants);
            private static bool Within(double value, double min, double max) => value >= min && (max == 0 || value <= max);
        }

        [Serializable]
        public sealed class Card
        {
            public string id, typeId;
            public GameObject prefab;
            public EnemyDirectorTier tier;
            [Tooltip("SingleType normal packs only: one roll replaces at most one member, using eligible active-profile elites and complete-group credit. Zero disables upgrades. Saving conditions on expensive final outcomes: any positive chance can make an upgraded-only target eligible. Ignored on elite cards.")]
            [Range(0, 1)] public double singlePackEliteChance;
            public double cost = 10;
            [Tooltip("Weight for direct card selection. On elite cards this also weights eligible elite replacement variants; it is separate from the normal card's pack upgrade chance.")]
            public double weight = 1;
            public Eligibility eligibility;
        }

        [Serializable]
        public sealed class Template
        {
            public string id;
            public EnemyCompositionDefinition composition;
            public double weight = 1;
            public Eligibility eligibility;
        }

        [Serializable]
        public sealed class Profile
        {
            public string id = "exploration";
            public double baseIncome = 10, bankCeiling = 100, initialBalance = 20, purchaseInterval = 4;
            public double savingChance = .25, savingSeconds = 12;
            public double memberStagger = .4, pendingLifetime = 20, arrivalSeconds = 1.25;
            [Range(1, 16)] public int admissionLimit = 16;
            [Range(1, 5)] public int singleMinimum = 1, singleMaximum = 5, proceduralMinimum = 2, proceduralMaximum = 5;
            public double singleWeight = 1, templateWeight = 1, proceduralWeight = 1;
            public string[] cardIds = Array.Empty<string>(), templateIds = Array.Empty<string>();
        }

        [Serializable]
        public struct HardExclusion { public string firstType, secondType; }
        [Serializable]
        public struct SoftModifier { public string triggerType, candidateType; public double multiplier; }

        public Card[] cards = Array.Empty<Card>();
        public Template[] templates = Array.Empty<Template>();
        public Profile[] profiles = Array.Empty<Profile>();
        public HardExclusion[] hardExclusions = Array.Empty<HardExclusion>();
        public SoftModifier[] softModifiers = Array.Empty<SoftModifier>();
        public NetworkPrefabsList[] prefabRegistries = Array.Empty<NetworkPrefabsList>();

        public sealed class CardSettings
        {
            public string Id { get; }
            public string TypeId { get; }
            public GameObject Prefab { get; }
            public EnemyDirectorTier Tier { get; }
            public double Cost { get; }
            public double Weight { get; }
            public double SinglePackEliteChance { get; }
            public Eligibility Eligibility { get; }
            public EnemyArchetype Archetype { get; }
            public EnemyRole Role { get; }
            public int AgentType { get; }
            public float Radius { get; }
            public float Height { get; }
            internal CardSettings(Card card, EnemyDefinition definition, int agent, float radius, float height)
            {
                Id = card.id; TypeId = card.typeId; Prefab = card.prefab; Tier = card.tier; Cost = card.cost; Weight = card.weight;
                SinglePackEliteChance = card.singlePackEliteChance;
                Eligibility = card.eligibility; Archetype = definition.archetype; Role = definition.role;
                AgentType = agent; Radius = radius; Height = height;
            }
        }

        public sealed class TemplateSettings
        {
            public string Id { get; }
            public double Weight { get; }
            public Eligibility Eligibility { get; }
            public EnemyFaction Faction { get; }
            public ReadOnlyCollection<CardSettings> Members { get; }
            public double Cost { get; }
            internal TemplateSettings(Template template, CardSettings[] members)
            {
                Id = template.id; Weight = template.weight; Eligibility = template.eligibility;
                Faction = template.composition.faction; Members = Array.AsReadOnly(members);
                Cost = members.Sum(x => x.Cost);
            }
        }

        public sealed class ProfileSettings
        {
            public string Id { get; }
            public double BaseIncome { get; }
            public double BankCeiling { get; }
            public double InitialBalance { get; }
            public double PurchaseInterval { get; }
            public double SavingChance { get; }
            public double SavingSeconds { get; }
            public double MemberStagger { get; }
            public double PendingLifetime { get; }
            public double ArrivalSeconds { get; }
            public int AdmissionLimit { get; }
            public int SingleMinimum { get; }
            public int SingleMaximum { get; }
            public int ProceduralMinimum { get; }
            public int ProceduralMaximum { get; }
            public double SingleWeight { get; }
            public double TemplateWeight { get; }
            public double ProceduralWeight { get; }
            public ReadOnlyCollection<CardSettings> Cards { get; }
            public ReadOnlyCollection<TemplateSettings> Templates { get; }
            internal ProfileSettings(Profile profile, CardSettings[] pool, TemplateSettings[] compositions)
            {
                Id = profile.id; BaseIncome = profile.baseIncome; BankCeiling = profile.bankCeiling;
                InitialBalance = profile.initialBalance; PurchaseInterval = profile.purchaseInterval;
                SavingChance = profile.savingChance; SavingSeconds = profile.savingSeconds; AdmissionLimit = profile.admissionLimit;
                MemberStagger = profile.memberStagger; PendingLifetime = profile.pendingLifetime; ArrivalSeconds = profile.arrivalSeconds;
                SingleMinimum = profile.singleMinimum; SingleMaximum = profile.singleMaximum;
                ProceduralMinimum = profile.proceduralMinimum; ProceduralMaximum = profile.proceduralMaximum;
                SingleWeight = profile.singleWeight; TemplateWeight = profile.templateWeight; ProceduralWeight = profile.proceduralWeight;
                Cards = Array.AsReadOnly(pool); Templates = Array.AsReadOnly(compositions);
            }
        }

        public sealed class Settings
        {
            public ReadOnlyCollection<CardSettings> Cards { get; }
            public ReadOnlyCollection<TemplateSettings> Templates { get; }
            public ReadOnlyCollection<ProfileSettings> Profiles { get; }
            public ReadOnlyCollection<HardExclusion> HardExclusions { get; }
            public ReadOnlyCollection<SoftModifier> SoftModifiers { get; }
            internal Settings(CardSettings[] pool, TemplateSettings[] compositions, ProfileSettings[] captured, HardExclusion[] hard, SoftModifier[] soft)
            {
                Cards = Array.AsReadOnly(pool); Templates = Array.AsReadOnly(compositions); Profiles = Array.AsReadOnly(captured);
                HardExclusions = Array.AsReadOnly((HardExclusion[])hard.Clone()); SoftModifiers = Array.AsReadOnly((SoftModifier[])soft.Clone());
            }
        }

        public Settings Capture()
        {
            Require(cards != null && cards.Length > 0 && cards.Length <= 32, "Use 1–32 explicit cards.");
            Require(templates != null && templates.Length <= 64 && profiles != null && profiles.Length > 0 && profiles.Length <= 8, "Invalid template/profile count.");
            Require(prefabRegistries != null && prefabRegistries.Length > 0 && prefabRegistries.All(x => x != null), "Missing prefab registries.");
            var capturedCards = new Dictionary<string, CardSettings>(StringComparer.Ordinal);
            foreach (var card in cards)
            {
                Require(card != null && Id(card.id) && Id(card.typeId) && !capturedCards.ContainsKey(card.id), "Missing/duplicate card ID or missing type ID.");
                var actor = card.prefab != null ? card.prefab.GetComponent<PrototypeEnemy>() : null;
                var definition = actor != null ? actor.definition : null;
                Require(definition != null && definition.Valid && !definition.boss && definition.archetype != EnemyArchetype.SplinterChild
                    && card.prefab.GetComponent<NetworkObject>() != null, "Card requires a nonboss/nonchild network enemy.");
                Require(Enum.IsDefined(typeof(EnemyDirectorTier), card.tier) && Positive(card.cost) && Positive(card.weight) && card.eligibility.Valid, "Invalid card tier/cost/weight/eligibility.");
                Require(Finite(card.singlePackEliteChance) && card.singlePackEliteChance >= 0 && card.singlePackEliteChance <= 1,
                    "Single-pack elite chance must be finite and between zero and one.");
                Require(!definition.EliteOnly || card.tier == EnemyDirectorTier.Elite, "Bombardier cards must use the Elite tier.");
                Require(prefabRegistries.Count(x => x.Contains(card.prefab)) == 1, "Card must be registered exactly once.");
                bool elite = card.tier == EnemyDirectorTier.Elite;
                Require(EnemySpawnCircleRules.TryResolveClearance(definition, elite, out float radius, out float height, out _), "Unsupported card geometry.");
                int agent = definition.ResolveAgentType(elite);
                var native = NavMesh.GetSettingsByID(agent);
                Require(native.agentTypeID == agent && native.agentRadius >= radius && native.agentHeight >= height, "Unsupported native navigation envelope.");
                capturedCards.Add(card.id, new CardSettings(card, definition, agent, radius, height));
            }
            Require(capturedCards.Values.GroupBy(x => x.TypeId).All(g => g.Select(x => x.Prefab).Distinct().Count() == 1)
                && capturedCards.Values.GroupBy(x => x.Prefab).All(g => g.Select(x => x.TypeId).Distinct().Count() == 1), "A type ID must identify one prefab across tiers.");
            var capturedTemplates = new Dictionary<string, TemplateSettings>(StringComparer.Ordinal);
            foreach (var template in templates)
            {
                Require(template != null && Id(template.id) && !capturedTemplates.ContainsKey(template.id)
                    && Positive(template.weight) && template.eligibility.Valid, "Invalid/duplicate template.");
                var composition = template.composition;
                Require(composition != null && composition.members != null && composition.directorMembers != null
                    && composition.members.Length >= 2 && composition.members.Length <= 5
                    && composition.directorMembers.Length == composition.members.Length && Enum.IsDefined(typeof(EnemyFaction), composition.faction), "Invalid director composition.");
                var members = new CardSettings[composition.members.Length];
                for (int i = 0; i < members.Length; i++)
                {
                    var binding = composition.directorMembers[i];
                    Require(Id(binding.cardId) && capturedCards.TryGetValue(binding.cardId, out members[i]), "Unknown template card.");
                    Require(members[i].Prefab == composition.members[i] && members[i].Tier == binding.tier, "Template prefab/tier differs from explicit card.");
                }
                Require(members.Count(x => x.Archetype == EnemyArchetype.TetherKeeper) <= 1
                    && members.Count(x => x.Archetype == EnemyArchetype.Lancer) <= 2 && Finite(members.Sum(x => x.Cost)), "Template exceeds specialist/cost limits.");
                capturedTemplates.Add(template.id, new TemplateSettings(template, members));
            }
            ValidateCompatibility();
            var ids = new HashSet<string>(StringComparer.Ordinal);
            var capturedProfiles = new List<ProfileSettings>();
            foreach (var profile in profiles)
            {
                Require(profile != null && Id(profile.id) && ids.Add(profile.id), "Missing/duplicate profile ID.");
                Require(Finite(profile.baseIncome) && profile.baseIncome >= 0 && Positive(profile.bankCeiling)
                    && Finite(profile.initialBalance) && profile.initialBalance >= 0 && profile.initialBalance <= profile.bankCeiling
                    && (profile.baseIncome > 0 || profile.initialBalance == profile.bankCeiling)
                    && Positive(profile.purchaseInterval) && Positive(profile.savingSeconds)
                    && Positive(profile.memberStagger) && profile.memberStagger <= 5 && Positive(profile.pendingLifetime) && profile.pendingLifetime <= 300
                    && Positive(profile.arrivalSeconds) && profile.arrivalSeconds <= 10
                    && Finite(profile.savingChance) && profile.savingChance >= 0 && profile.savingChance <= 1, "Invalid profile finances/deadlines.");
                Require(profile.admissionLimit >= 1 && profile.admissionLimit <= 16
                    && Size(profile.singleMinimum, profile.singleMaximum) && Size(profile.proceduralMinimum, profile.proceduralMaximum), "Invalid profile group/admission limits.");
                Require(Weight(profile.singleWeight) && Weight(profile.templateWeight) && Weight(profile.proceduralWeight)
                    && profile.singleWeight + profile.templateWeight + profile.proceduralWeight > 0, "Enable at least one weighted mode.");
                Require(profile.cardIds != null && profile.templateIds != null && profile.cardIds.Distinct().Count() == profile.cardIds.Length
                    && profile.templateIds.Distinct().Count() == profile.templateIds.Length
                    && profile.cardIds.All(x => Id(x) && capturedCards.ContainsKey(x))
                    && profile.templateIds.All(x => Id(x) && capturedTemplates.ContainsKey(x)), "Invalid/duplicate profile pool reference.");
                var pool = profile.cardIds.Select(x => capturedCards[x]).ToArray();
                var compositions = profile.templateIds.Select(x => capturedTemplates[x]).ToArray();
                Require(compositions.All(x => x.Members.All(m => pool.Contains(m))), "Template members must belong to profile pool.");
                capturedProfiles.Add(new ProfileSettings(profile, pool, compositions));
            }
            var settings = new Settings(capturedCards.Values.ToArray(), capturedTemplates.Values.ToArray(), capturedProfiles.ToArray(), hardExclusions, softModifiers);
            foreach (var profile in settings.Profiles)
                Require(EnemyGroupSelection.HasAffordableModes(settings, profile), "Every enabled mode requires an eligible complete purchase within its ceiling and admission limit.");
            return settings;
        }

        private void ValidateCompatibility()
        {
            Require(hardExclusions != null && hardExclusions.Length <= 64 && softModifiers != null && softModifiers.Length <= 64, "Invalid compatibility rules.");
            var types = new HashSet<string>(cards.Select(x => x.typeId), StringComparer.Ordinal);
            var hard = new HashSet<(string, string)>();
            foreach (var rule in hardExclusions)
            {
                Require(Id(rule.firstType) && Id(rule.secondType) && types.Contains(rule.firstType) && types.Contains(rule.secondType)
                    && hard.Add(Pair(rule.firstType, rule.secondType)), "Invalid/duplicate symmetric exclusion.");
            }
            var soft = new HashSet<(string, string)>();
            foreach (var rule in softModifiers)
                Require(Id(rule.triggerType) && Id(rule.candidateType) && types.Contains(rule.triggerType) && types.Contains(rule.candidateType) && Positive(rule.multiplier)
                    && soft.Add((rule.triggerType, rule.candidateType)) && !hard.Contains(Pair(rule.triggerType, rule.candidateType)), "Invalid/duplicate/conflicting soft modifier.");
        }
        internal static (string, string) Pair(string a, string b) => string.CompareOrdinal(a, b) <= 0 ? (a, b) : (b, a);
        private static bool Size(int min, int max) => min >= 1 && max >= min && max <= 5;
        private static bool Id(string value) => !string.IsNullOrWhiteSpace(value);
        private static bool Weight(double value) => Finite(value) && value >= 0;
        internal static bool Positive(double value) => Finite(value) && value > 0;
        internal static bool Finite(double value) => !double.IsNaN(value) && !double.IsInfinity(value);
        private static void Require(bool condition, string error) { if (!condition) throw new ArgumentException(error); }
    }
}