using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;
using WarGame.Data;

namespace WarGame.Units
{
    public enum UnitTeam
    {
        Player,
        Enemy
    }

    public enum UnitState
    {
        Idle,
        Approaching,
        Flanking,
        Attacking,
        FeintRetreating,
        Dead
    }

    [RequireComponent(typeof(Collider))]
    public class Unit : MonoBehaviour
    {
        [Header("Identity & Team")]
        [SerializeField] private UnitTeam team = UnitTeam.Player;
        [SerializeField] private UnitDataSO unitData;
        [SerializeField] private int initialLevel = 1;

        [Header("Components & Visuals")]
        [SerializeField] private NavMeshAgent agent;
        [SerializeField] private UnitHealthBar healthBar;
        [SerializeField] private Animator animator;
        [SerializeField] private Renderer mainRenderer;

        // Runtime progression & stats
        public UnitProgression Progression { get; private set; }
        public UnitTeam Team => team;
        public UnitDataSO UnitData => unitData;
        public UnitState CurrentState { get; private set; } = UnitState.Idle;
        public Unit CurrentTarget { get; private set; }

        public float CurrentHealth { get; private set; }
        public float MaxHealth { get; private set; }
        public float AttackDamage { get; private set; }
        public float DefenseArmor { get; private set; }
        public float MoveSpeed { get; private set; }
        public float AttackRange { get; private set; }
        public float AttackInterval { get; private set; }
        public float CriticalChance { get; private set; }

        // Battle state
        private bool isBattleActive = false;
        private float lastAttackTime = -999f;
        private Vector3 initialSpawnPosition;
        private Quaternion initialSpawnRotation;

        // Tactics State
        private float feintRetreatCooldownTimer = 0f;
        private float feintRetreatDurationTimer = 0f;
        private bool hasTriggeredFeintThisBattle = false;
        private Vector3 flankDestination;
        private float flankSearchTimer = 0f;
        private float targetSearchTimer = 0f;

        // Animation IDs (if animator present)
        private static readonly int SpeedHash = Animator.StringToHash("Speed");
        private static readonly int AttackHash = Animator.StringToHash("Attack");
        private static readonly int DieHash = Animator.StringToHash("Die");
        private static readonly int HitHash = Animator.StringToHash("Hit");

        // Events
        public event Action<Unit> OnUnitDied;
        public event Action<float, float> OnHealthChanged;

        private void Awake()
        {
            if (agent == null) agent = GetComponent<NavMeshAgent>();
            initialSpawnPosition = transform.position;
            initialSpawnRotation = transform.rotation;
        }

        public void Initialize(UnitDataSO data, UnitTeam unitTeam, int startingLevel = 1)
        {
            unitData = data;
            team = unitTeam;
            initialLevel = startingLevel;

            Progression = new UnitProgression(unitData, initialLevel);
            Progression.OnLevelUp += HandleLevelUp;
            Progression.OnTacticUnlocked += HandleTacticUnlocked;

            RefreshStats();
            CurrentHealth = MaxHealth;

            ApplyTeamColors();

            if (healthBar != null)
            {
                healthBar.Initialize(transform, team == UnitTeam.Player, unitData != null ? unitData.unitName : name, Progression.CurrentLevel);
                healthBar.UpdateHealth(CurrentHealth, MaxHealth);
            }
        }

        public void SetProgression(UnitProgression existingProgression)
        {
            if (existingProgression != null)
            {
                Progression = existingProgression;
                unitData = Progression.UnitData;
                Progression.OnLevelUp += HandleLevelUp;
                Progression.OnTacticUnlocked += HandleTacticUnlocked;
                RefreshStats();
                CurrentHealth = MaxHealth;

                if (healthBar != null)
                {
                    healthBar.UpdateLevel(Progression.CurrentLevel);
                    healthBar.UpdateHealth(CurrentHealth, MaxHealth);
                }
            }
        }

        private void RefreshStats()
        {
            if (Progression == null) return;

            MaxHealth = Progression.GetMaxHealth();
            AttackDamage = Progression.GetAttackDamage();
            DefenseArmor = Progression.GetDefenseArmor();
            MoveSpeed = Progression.GetMoveSpeed();
            AttackRange = Progression.GetAttackRange();
            AttackInterval = Progression.GetAttackInterval();
            CriticalChance = Progression.GetCriticalChance();

            if (agent != null)
            {
                agent.speed = MoveSpeed;
                agent.stoppingDistance = Mathf.Max(0.5f, AttackRange * 0.8f);
            }
        }

        private void ApplyTeamColors()
        {
            if (mainRenderer != null)
            {
                Color tint = team == UnitTeam.Player ? new Color(0.2f, 0.6f, 1f) : new Color(1f, 0.25f, 0.25f);
                mainRenderer.material.color = tint;
            }
        }

        public void StartBattle()
        {
            isBattleActive = true;
            CurrentState = UnitState.Approaching;
            hasTriggeredFeintThisBattle = false;
            feintRetreatDurationTimer = 0f;
            lastAttackTime = Time.time - UnityEngine.Random.Range(0f, AttackInterval * 0.5f);
        }

        public void EndBattle(bool restorePosition = false)
        {
            isBattleActive = false;
            CurrentState = UnitState.Idle;
            StopMovement();

            if (restorePosition && CurrentHealth > 0)
            {
                // Move back to spawn position and full heal between rounds
                WarpToPosition(initialSpawnPosition, initialSpawnRotation);
                HealToFull();
            }
        }

        public void HealToFull()
        {
            CurrentHealth = MaxHealth;
            OnHealthChanged?.Invoke(CurrentHealth, MaxHealth);
            if (healthBar != null) healthBar.UpdateHealth(CurrentHealth, MaxHealth);
        }

        private void Update()
        {
            if (CurrentState == UnitState.Dead) return;

            // Handle Tactic Cooldowns
            if (feintRetreatCooldownTimer > 0) feintRetreatCooldownTimer -= Time.deltaTime;

            UpdateAnimation();

            if (!isBattleActive) return;

            // AI Decision Loop
            switch (CurrentState)
            {
                case UnitState.Approaching:
                    HandleApproachingState();
                    break;
                case UnitState.Flanking:
                    HandleFlankingState();
                    break;
                case UnitState.Attacking:
                    HandleAttackingState();
                    break;
                case UnitState.FeintRetreating:
                    HandleFeintRetreatState();
                    break;
                case UnitState.Idle:
                    FindBestTarget();
                    if (CurrentTarget != null) CurrentState = UnitState.Approaching;
                    break;
            }
        }

        #region Tactical AI Logic

        private void FindBestTarget()
        {
            targetSearchTimer -= Time.deltaTime;
            if (targetSearchTimer > 0 && CurrentTarget != null && CurrentTarget.IsAlive()) return;
            targetSearchTimer = 0.5f;

            Unit closest = null;
            float closestDistanceSqr = float.MaxValue;
            List<Unit> allUnits = BattleManager.Instance != null ? BattleManager.Instance.AllActiveUnits : null;

            if (allUnits == null) return;

            for (int i = 0; i < allUnits.Count; i++)
            {
                Unit candidate = allUnits[i];
                if (candidate == null || candidate == this || candidate.Team == team || !candidate.IsAlive()) continue;

                float distSqr = (candidate.transform.position - transform.position).sqrMagnitude;
                if (distSqr < closestDistanceSqr)
                {
                    closestDistanceSqr = distSqr;
                    closest = candidate;
                }
            }

            CurrentTarget = closest;
        }

        private void HandleApproachingState()
        {
            if (CurrentTarget == null || !CurrentTarget.IsAlive())
            {
                FindBestTarget();
                if (CurrentTarget == null)
                {
                    StopMovement();
                    CurrentState = UnitState.Idle;
                    return;
                }
            }

            // Check if Feint Retreat should be triggered
            if (CheckAndTriggerFeintRetreat()) return;

            // Check if Flanking maneuver should be initiated
            if (CheckAndTriggerFlanking()) return;

            float distance = Vector3.Distance(transform.position, CurrentTarget.transform.position);
            if (distance <= AttackRange)
            {
                StopMovement();
                CurrentState = UnitState.Attacking;
            }
            else
            {
                MoveTowards(CurrentTarget.transform.position);
            }
        }

        private bool CheckAndTriggerFlanking()
        {
            if (Progression == null || CurrentTarget == null) return false;

            flankSearchTimer -= Time.deltaTime;
            if (flankSearchTimer > 0) return false;
            flankSearchTimer = 1.5f;

            if (Progression.HasTactic(UnitTacticType.Flanking, out UnlockedTactic flankConfig))
            {
                // Flanking is ideal if target is engaged with another friendly unit or target is not facing this unit
                Vector3 toAttacker = (transform.position - CurrentTarget.transform.position).normalized;
                float angle = Vector3.Angle(CurrentTarget.transform.forward, toAttacker);

                // If already at flank (angle > 50 degrees) or if we want to reposition to rear
                if (angle < 60f)
                {
                    // Compute flanking point: 90 degrees offset to left or right, or behind
                    Vector3 flankSide = UnityEngine.Random.value > 0.5f ? CurrentTarget.transform.right : -CurrentTarget.transform.right;
                    Vector3 flankPos = CurrentTarget.transform.position + (-CurrentTarget.transform.forward * 1.5f + flankSide * 2f);

                    flankDestination = flankPos;
                    CurrentState = UnitState.Flanking;

                    if (healthBar != null)
                    {
                        healthBar.ShowTacticAlert("FLANKING!", new Color(1f, 0.85f, 0.2f), 2f);
                    }
                    return true;
                }
            }
            return false;
        }

        private void HandleFlankingState()
        {
            if (CurrentTarget == null || !CurrentTarget.IsAlive())
            {
                CurrentState = UnitState.Approaching;
                return;
            }

            if (CheckAndTriggerFeintRetreat()) return;

            float distanceToTarget = Vector3.Distance(transform.position, CurrentTarget.transform.position);
            if (distanceToTarget <= AttackRange)
            {
                StopMovement();
                CurrentState = UnitState.Attacking;
                return;
            }

            // Move along flank perimeter
            MoveTowards(flankDestination);

            if (Vector3.Distance(transform.position, flankDestination) < 1.0f)
            {
                // Reached flank position, now attack!
                CurrentState = UnitState.Attacking;
            }
        }

        private bool CheckAndTriggerFeintRetreat()
        {
            if (hasTriggeredFeintThisBattle || feintRetreatCooldownTimer > 0) return false;
            if (Progression == null) return false;

            if (Progression.HasTactic(UnitTacticType.FeintRetreat, out UnlockedTactic config))
            {
                float hpPercent = CurrentHealth / MaxHealth;
                if (hpPercent <= config.triggerThreshold)
                {
                    hasTriggeredFeintThisBattle = true;
                    feintRetreatDurationTimer = config.duration;
                    feintRetreatCooldownTimer = config.cooldown;
                    CurrentState = UnitState.FeintRetreating;

                    if (healthBar != null)
                    {
                        healthBar.ShowTacticAlert("FEINT RETREAT!", new Color(0.4f, 1f, 0.4f), 3f);
                    }
                    return true;
                }
            }
            return false;
        }

        private void HandleFeintRetreatState()
        {
            feintRetreatDurationTimer -= Time.deltaTime;

            // Run away from current target or towards initial spawn/friendly lines
            Vector3 retreatDirection;
            if (CurrentTarget != null)
            {
                retreatDirection = (transform.position - CurrentTarget.transform.position).normalized;
            }
            else
            {
                retreatDirection = (initialSpawnPosition - transform.position).normalized;
            }

            Vector3 retreatTargetPos = transform.position + retreatDirection * 5f;
            MoveTowards(retreatTargetPos, MoveSpeed * 1.3f); // Sprint during retreat

            if (feintRetreatDurationTimer <= 0)
            {
                // Feint ended! Rally, turn around and counter-attack with a temporary morale boost
                if (healthBar != null)
                {
                    healthBar.ShowTacticAlert("COUNTER-STRIKE!", Color.cyan, 2f);
                }
                CurrentState = UnitState.Approaching;
            }
        }

        private void HandleAttackingState()
        {
            if (CurrentTarget == null || !CurrentTarget.IsAlive())
            {
                CurrentState = UnitState.Approaching;
                return;
            }

            if (CheckAndTriggerFeintRetreat()) return;

            float distance = Vector3.Distance(transform.position, CurrentTarget.transform.position);
            if (distance > AttackRange * 1.25f)
            {
                CurrentState = UnitState.Approaching;
                return;
            }

            // Face target
            Vector3 lookDirection = (CurrentTarget.transform.position - transform.position).normalized;
            lookDirection.y = 0;
            if (lookDirection != Vector3.zero)
            {
                transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.LookRotation(lookDirection), Time.deltaTime * 10f);
            }

            // Attack on cooldown
            if (Time.time - lastAttackTime >= AttackInterval)
            {
                ExecuteAttack();
            }
        }

        private void ExecuteAttack()
        {
            lastAttackTime = Time.time;

            if (animator != null)
            {
                animator.SetTrigger(AttackHash);
            }

            if (CurrentTarget == null || !CurrentTarget.IsAlive()) return;

            // Calculate flanking angle: angle between target forward and vector towards attacker
            Vector3 toAttacker = (transform.position - CurrentTarget.transform.position).normalized;
            float angle = Vector3.Angle(CurrentTarget.transform.forward, toAttacker);
            bool isFlankAttack = angle > 60f;

            float finalDamage = AttackDamage;

            // Critical hit calculation
            bool isCrit = UnityEngine.Random.value < CriticalChance;
            if (isCrit) finalDamage *= 1.5f;

            // Flank bonus calculation if flanking tactic is unlocked
            if (isFlankAttack && Progression != null && Progression.HasTactic(UnitTacticType.Flanking, out UnlockedTactic flankConfig))
            {
                finalDamage *= flankConfig.valueMultiplier;
                if (healthBar != null)
                {
                    healthBar.ShowTacticAlert("FLANK STRIKE!", new Color(1f, 0.4f, 0.1f), 1f);
                }
            }

            CurrentTarget.TakeDamage(finalDamage, this, isFlankAttack);
        }

        #endregion

        #region Damage & Progression

        public void TakeDamage(float rawDamage, Unit attacker, bool isFlank)
        {
            if (CurrentState == UnitState.Dead) return;

            // Mitigate with defense armor
            float effectiveDamage = Mathf.Max(1f, rawDamage - DefenseArmor);
            CurrentHealth -= effectiveDamage;

            if (animator != null)
            {
                animator.SetTrigger(HitHash);
            }

            OnHealthChanged?.Invoke(CurrentHealth, MaxHealth);
            if (healthBar != null)
            {
                healthBar.UpdateHealth(CurrentHealth, MaxHealth);
            }

            if (CurrentHealth <= 0)
            {
                Die(attacker);
            }
        }

        private void Die(Unit killer)
        {
            CurrentHealth = 0;
            CurrentState = UnitState.Dead;
            StopMovement();

            if (animator != null)
            {
                animator.SetTrigger(DieHash);
            }

            // Award XP to killer
            if (killer != null && killer.Progression != null)
            {
                int xpReward = unitData != null ? Mathf.RoundToInt(unitData.baseExpRequirement * 0.5f) : 25;
                killer.Progression.AddExperience(xpReward);
                killer.Progression.RecordKill();
            }

            OnUnitDied?.Invoke(this);

            if (BattleManager.Instance != null)
            {
                BattleManager.Instance.OnUnitDefeated(this);
            }

            // Start coroutine to disable or cleanup
            StartCoroutine(DeathFadeRoutine());
        }

        private IEnumerator DeathFadeRoutine()
        {
            yield return new WaitForSeconds(2.5f);
            if (healthBar != null) healthBar.gameObject.SetActive(false);
            gameObject.SetActive(false);
        }

        private void HandleLevelUp(int newLevel)
        {
            RefreshStats();
            CurrentHealth = MaxHealth; // Heal up on level up
            if (healthBar != null)
            {
                healthBar.UpdateLevel(newLevel);
                healthBar.UpdateHealth(CurrentHealth, MaxHealth);
                healthBar.ShowTacticAlert($"LEVEL UP! (Lv.{newLevel})", Color.yellow, 2.5f);
            }
        }

        private void HandleTacticUnlocked(UnlockedTactic tactic)
        {
            if (healthBar != null)
            {
                healthBar.ShowTacticAlert($"NEW TACTIC: {tactic.tacticType}!", Color.magenta, 3f);
            }
        }

        #endregion

        #region Movement & Navigation

        private void MoveTowards(Vector3 destination, float customSpeed = -1f)
        {
            float speedToUse = customSpeed > 0 ? customSpeed : MoveSpeed;

            if (agent != null && agent.isOnNavMesh)
            {
                agent.isStopped = false;
                agent.speed = speedToUse;
                agent.SetDestination(destination);
            }
            else
            {
                // Fallback direct movement if NavMeshAgent is absent or off mesh
                Vector3 direction = (destination - transform.position).normalized;
                direction.y = 0;
                if (direction != Vector3.zero)
                {
                    transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.LookRotation(direction), Time.deltaTime * 10f);
                    transform.position += direction * (speedToUse * Time.deltaTime);
                }
            }
        }

        private void StopMovement()
        {
            if (agent != null && agent.isOnNavMesh)
            {
                agent.isStopped = true;
                agent.ResetPath();
            }
        }

        public void WarpToPosition(Vector3 position, Quaternion rotation)
        {
            transform.position = position;
            transform.rotation = rotation;

            if (agent != null && agent.isOnNavMesh)
            {
                agent.Warp(position);
            }
        }

        private void UpdateAnimation()
        {
            if (animator == null) return;

            float currentSpeed = 0f;
            if (agent != null && agent.isOnNavMesh)
            {
                currentSpeed = agent.velocity.magnitude;
            }
            animator.SetFloat(SpeedHash, currentSpeed);
        }

        public bool IsAlive() => CurrentState != UnitState.Dead && CurrentHealth > 0;

        #endregion
    }
}