using System;
using System.Collections.Generic;
using UnityEngine;

namespace Heroes.Battle
{
    /// <summary>Display/behaviour state of a stack, driven as a finite state machine.</summary>
    public enum UnitStackState
    {
        /// <summary>Waiting for its turn.</summary>
        Idle,

        /// <summary>It is this stack's turn: the player is choosing an action.</summary>
        Active,

        /// <summary>Gliding along <see cref="UnitStack.MovePath"/> towards a hex.</summary>
        Moving,

        /// <summary>Playing an attack against <see cref="UnitStack.AttackTarget"/>.</summary>
        Attacking,

        /// <summary>Stack was wiped out; no longer participates.</summary>
        Dead,
    }

    /// <summary>
    /// Runtime state of one deployed stack of units, modelled as a small finite
    /// state machine so the view can react to state transitions instead of being
    /// driven imperatively. Pure C#: holds grid position, live health and current
    /// action payloads (move path, attack target); the controller advances the
    /// machine and the view animates each state.
    ///
    /// State flow for a turn:
    ///   Idle --Activate--> Active
    ///   Active --StartMove--> Moving --CompleteMove--> Active
    ///   Active --StartAttack--> Attacking --CompleteAttack--> Active
    ///   Active --Deactivate--> Idle
    ///   (any) --Kill--> Dead
    /// </summary>
    public sealed class UnitStack
    {
        /// <summary>Raised after <see cref="State"/> changes. Argument is this stack.</summary>
        public event Action<UnitStack> StateChanged;

        /// <summary>Raised after the stack's health/count changes (e.g. took damage).</summary>
        public event Action<UnitStack> HealthChanged;

        private readonly List<Vector2Int> _movePath = new List<Vector2Int>();

        public UnitStack(UnitDefinition definition, int count, BattleSide side, int slotIndex, int x, int y)
        {
            Definition = definition;
            Side = side;
            SlotIndex = slotIndex;
            X = x;
            Y = y;
            MaxUnitHealth = definition != null ? Mathf.Max(1, definition.health) : 1;
            TotalHealth = Mathf.Max(0, count) * MaxUnitHealth;
            State = UnitStackState.Idle;
        }

        public UnitDefinition Definition { get; }

        public BattleSide Side { get; }

        /// <summary>Index of the army slot (0..6) this stack came from.</summary>
        public int SlotIndex { get; }

        /// <summary>Anchor column. Wide units extend towards the battlefield center.</summary>
        public int X { get; private set; }

        /// <summary>Row on the battlefield grid.</summary>
        public int Y { get; private set; }

        public UnitStackState State { get; private set; }

        /// <summary>Health of a single unit in the stack.</summary>
        public int MaxUnitHealth { get; }

        /// <summary>Current total health of the whole stack.</summary>
        public int TotalHealth { get; private set; }

        /// <summary>Live unit count, derived from total health (a partially wounded top unit still counts).</summary>
        public int Count => TotalHealth <= 0 ? 0 : Mathf.CeilToInt((float)TotalHealth / MaxUnitHealth);

        public bool IsAlive => State != UnitStackState.Dead && TotalHealth > 0;

        /// <summary>Movement range in hexes (equal to the unit's speed).</summary>
        public int Speed => Definition != null ? Mathf.Max(1, Definition.speed) : 1;

        public int Attack => Definition != null ? Mathf.Max(0, Definition.attack) : 0;

        public int Defense => Definition != null ? Mathf.Max(0, Definition.defense) : 0;

        public int HexWidth => Definition != null && Definition.hexWidth > 1 ? 2 : 1;

        /// <summary>Hex anchors to walk through during the current <see cref="UnitStackState.Moving"/> state.</summary>
        public IReadOnlyList<Vector2Int> MovePath => _movePath;

        /// <summary>Target of the current <see cref="UnitStackState.Attacking"/> state.</summary>
        public UnitStack AttackTarget { get; private set; }

        /// <summary>
        /// Columns occupied on row <see cref="Y"/>. The anchor sits at the army
        /// edge; the second hex of a wide unit extends towards the center.
        /// </summary>
        public IEnumerable<int> OccupiedColumns() => ColumnsFor(Side, HexWidth, X);

        /// <summary>Columns a stack of the given side/width would occupy at an arbitrary anchor.</summary>
        public static IEnumerable<int> ColumnsFor(BattleSide side, int width, int anchorX)
        {
            int w = Mathf.Max(1, width);
            for (int i = 0; i < w; i++)
            {
                yield return side == BattleSide.Attacker ? anchorX + i : anchorX - i;
            }
        }

        // --- State transitions -------------------------------------------------

        public void Activate()
        {
            if (State == UnitStackState.Dead) return;
            SetState(UnitStackState.Active);
        }

        public void Deactivate()
        {
            if (State == UnitStackState.Dead) return;
            SetState(UnitStackState.Idle);
        }

        /// <summary>Enters the Moving state with the given path of hex anchors (excluding the start hex).</summary>
        public void StartMove(IReadOnlyList<Vector2Int> path)
        {
            if (State == UnitStackState.Dead) return;
            _movePath.Clear();
            if (path != null) _movePath.AddRange(path);
            SetState(UnitStackState.Moving);
        }

        /// <summary>Called by the view once the move animation finishes; commits the final position.</summary>
        public void CompleteMove()
        {
            if (_movePath.Count > 0)
            {
                var end = _movePath[_movePath.Count - 1];
                X = end.x;
                Y = end.y;
            }
            _movePath.Clear();
            if (State == UnitStackState.Dead) return;
            SetState(UnitStackState.Active);
        }

        public void StartAttack(UnitStack target)
        {
            if (State == UnitStackState.Dead) return;
            AttackTarget = target;
            SetState(UnitStackState.Attacking);
        }

        /// <summary>Called by the view once the attack animation finishes.</summary>
        public void CompleteAttack()
        {
            AttackTarget = null;
            if (State == UnitStackState.Dead) return;
            SetState(UnitStackState.Active);
        }

        /// <summary>Applies damage to the stack's total health; kills it if it drops to zero.</summary>
        public void ApplyDamage(int amount)
        {
            if (amount <= 0 || State == UnitStackState.Dead) return;
            TotalHealth = Mathf.Max(0, TotalHealth - amount);
            HealthChanged?.Invoke(this);
            if (TotalHealth <= 0) SetState(UnitStackState.Dead);
        }

        private void SetState(UnitStackState next)
        {
            if (State == next) return;
            State = next;
            StateChanged?.Invoke(this);
        }
    }
}