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

namespace TKS
{
    /// <summary>유닛 1기의 스킬 상태(액티브 쿨·예약 · 패시브 · 행동 뒤에도 남는 효과).</summary>
    public class UnitSkills
    {
        public Unit Unit;
        public string HeroId = "";
        /// <summary>무장(영웅·보스·엘리트 장수) — 참장·파로(dmg_vs_general_mult) 대상 판정.</summary>
        public bool IsGeneral;

        public SkillDef Active;
        public int ActiveLv = 1;
        public List<SkillEffect> ActiveEffects;
        public SkillDef Passive;
        public int PassiveLv = 1;
        public float PassiveMult = 1f;
        public List<SkillEffect> PassiveEffects;

        /// <summary>액티브를 쓸 수 있는 첫 아군 턴(전투 시작 = 1 · 사용 턴 + 쿨).</summary>
        public int ReadyTurn = 1;
        /// <summary>next_action 예약(다음 슬링샷 1회) · 행동 전 다시 탭 = 취소.</summary>
        public bool Reserved;
        /// <summary>예약한 효과가 지금 걸려 있다(그 유닛의 행동 처리·조준 미리보기 동안만).</summary>
        public bool Armed;

        /// <summary>추가 이동: 지금 것 다음에 더 남은 횟수 · 추가 이동에서 공격 가능.</summary>
        public int BonusMovesLeft;
        public bool BonusAttack;
        /// <summary>대기(견제) 중 액티브로 얻은 반경 배율·가산·무제한(그 적 턴까지).</summary>
        public float OwMult = 1f;
        public float OwAdd;
        public bool OwUnlimited;
        /// <summary>전투 중 관통한 적 누적(장료 팔백 돌격).</summary>
        public int PierceHits;

        public bool HasActive
        {
            get { return Active != null && ActiveEffects != null; }
        }

        public int CooldownLeft(int turn)
        {
            return Mathf.Max(0, ReadyTurn - turn);
        }
    }

    /// <summary>스킬 효과 1건이 어느 유닛·스킬에서 왔는가(SkillMods 질의 결과).</summary>
    public struct SkillHit
    {
        public UnitSkills Owner;
        public SkillDef Def;
        public SkillEffect E;
        public bool Passive;
    }

    /// <summary>
    /// 전투 1판의 스킬 처리(PD #1093 B · 시스템 기획 §5): 유닛별 스킬 상태 · 즉시형 액티브의 시한 효과(이번 아군 턴 / 이번 적 턴) ·
    /// 행동 전후 훅(예약 효과 장착·쿨 소모) · 피해 적용(호위 분담) · HUD 한 줄 기록. 수치 질의는 SkillMods.
    /// </summary>
    public class SkillSystem
    {
        public static SkillSystem Current;

        public class Timed
        {
            public UnitSkills Owner;
            public Faction Faction;
            public SkillDef Def;
            public SkillEffect E;
            /// <summary>true = 이번 적 턴에만 걸림(다음 아군 턴 시작에 사라짐) · false = 이번 아군 턴(적 턴 시작에 사라짐).</summary>
            public bool EnemyWindow;
            /// <summary>대상 고정(장판 일갈 = 밀어낸 적) · null = 키 규칙대로.</summary>
            public HashSet<Unit> Targets;
        }

        public struct LogLine
        {
            public string Text;
            public float Time;
        }

        readonly BattleManager battle;
        readonly Dictionary<Unit, UnitSkills> map = new Dictionary<Unit, UnitSkills>();
        readonly List<UnitSkills> entries = new List<UnitSkills>();
        public readonly List<Timed> TimedEffects = new List<Timed>();
        public readonly List<LogLine> Log = new List<LogLine>();
        readonly HashSet<string> noted = new HashSet<string>();
        readonly int[] startCount = new int[2];

        /// <summary>장합 변진: 목표 지점 탭 대기 중인 유닛.</summary>
        public Unit PendingTeleport { get; private set; }

        public SkillSystem(BattleManager b)
        {
            battle = b;
        }

        public BattleManager Battle
        {
            get { return battle; }
        }

        public IReadOnlyList<UnitSkills> Entries
        {
            get { return entries; }
        }

        // ---------- 부착 ----------

        public UnitSkills Of(Unit u)
        {
            if (u == null) return null;
            UnitSkills s;
            return map.TryGetValue(u, out s) ? s : null;
        }

        UnitSkills Ensure(Unit u)
        {
            var s = Of(u);
            if (s != null) return s;
            s = new UnitSkills { Unit = u };
            map[u] = s;
            entries.Add(s);
            return s;
        }

        /// <summary>스킬 부착(액티브·패시브 id · 레벨 · ★5 패시브 배율 · 무장 여부). 최대 HP 패시브(hp_max_pct)는 바로 반영.</summary>
        public UnitSkills Attach(Unit u, string activeId, int activeLv, string passiveId, int passiveLv, float passiveMult, bool general)
        {
            if (u == null) return null;
            var s = Ensure(u);
            s.IsGeneral = general;
            s.Active = SkillCatalog.Get(activeId);
            s.ActiveLv = Mathf.Max(1, activeLv);
            s.ActiveEffects = s.Active != null ? s.Active.ScaledEffects(s.ActiveLv, 1f) : null;
            s.Passive = SkillCatalog.Get(passiveId);
            s.PassiveLv = Mathf.Max(1, passiveLv);
            s.PassiveMult = passiveMult > 0f ? passiveMult : 1f;
            s.PassiveEffects = s.Passive != null ? s.Passive.ScaledEffects(s.PassiveLv, s.PassiveMult) : null;
            if (s.Passive != null) s.HeroId = s.Passive.HeroId;
            else if (s.Active != null) s.HeroId = s.Active.HeroId;

            float hp = SkillMods.Sum(u, SkillKeys.HpMaxPct);
            if (Mathf.Abs(hp) > 1e-4f)
            {
                u.MaxHp = Mathf.Max(1, Mathf.RoundToInt(u.MaxHp * (1f + hp)));
                u.Hp = u.MaxHp;
                if (u.View != null) u.View.Refresh();
            }
            return s;
        }

        /// <summary>heroes.csv 영웅 id 로 부착(테스트·도구용).</summary>
        public UnitSkills AttachHero(Unit u, string heroId, int activeLv = 1, int passiveLv = 1, float passiveMult = 1f, bool general = true)
        {
            var h = SkillCatalog.Hero(heroId);
            if (h == null) return null;
            return Attach(u, h.skillActive, activeLv, h.skillPassive, passiveLv, passiveMult, general && !h.isSoldier);
        }

        /// <summary>출전 칸(편성 → 스킬 id·레벨·★ 배율이 채워져 있음).</summary>
        public UnitSkills AttachLineup(Unit u, LineupEntry e)
        {
            if (e == null) return null;
            if (string.IsNullOrEmpty(e.skillActive) && string.IsNullOrEmpty(e.skillPassive))
            {
                if (e.general) Ensure(u).IsGeneral = true;
                return Of(u);
            }
            return Attach(u, e.skillActive, e.activeLv, e.skillPassive, e.passiveLv, e.passiveMult, e.general);
        }

        /// <summary>적 무장(보스·엘리트) = heroes.csv 에 같은 아트·이름 영웅이 있으면 그 패시브만(Lv1 · 액티브 AI 사용은 2차 · PD 확인 대상).</summary>
        public UnitSkills AttachEnemy(Unit u, BalanceConfig.EnemySpawn e)
        {
            if (u == null || e == null || !(e.isBoss || e.isGeneral)) return null;
            var h = SkillCatalog.HeroForEnemy(e.art, e.name);
            if (h == null)
            {
                var s = Ensure(u);
                s.IsGeneral = true;
                return s;
            }
            return Attach(u, null, 1, h.skillPassive, 1, 1f, true);
        }

        public void MarkGeneral(Unit u)
        {
            if (u != null) Ensure(u).IsGeneral = true;
        }

        public bool IsGeneral(Unit u)
        {
            if (u == null) return false;
            if (u.IsBoss) return true;
            var s = Of(u);
            return s != null && s.IsGeneral;
        }

        public void Clear()
        {
            map.Clear();
            entries.Clear();
            TimedEffects.Clear();
            noted.Clear();
            PendingTeleport = null;
            startCount[0] = startCount[1] = 0;
        }

        /// <summary>전투 시작(배치 뒤): 출전 인원 기록(패자 · team_atk_pct_full) · 쿨 = 바로 사용 가능 · 시한 효과 비움.</summary>
        public void BeginBattle()
        {
            Prune();
            TimedEffects.Clear();
            noted.Clear();
            PendingTeleport = null;
            startCount[0] = battle.AliveCount(Faction.Player);
            startCount[1] = battle.AliveCount(Faction.Enemy);
            foreach (var s in entries)
            {
                s.ReadyTurn = 1;
                s.Reserved = false;
                s.Armed = false;
                s.BonusMovesLeft = 0;
                s.BonusAttack = false;
                s.OwMult = 1f;
                s.OwAdd = 0f;
                s.OwUnlimited = false;
                s.PierceHits = 0;
            }
        }

        public int StartCount(Faction f)
        {
            return startCount[(int)f];
        }

        void Prune()
        {
            for (int i = entries.Count - 1; i >= 0; i--)
            {
                if (entries[i].Unit != null) continue;
                entries.RemoveAt(i);
            }
            var dead = new List<Unit>();
            foreach (var kv in map)
                if (kv.Key == null) dead.Add(kv.Key);
            foreach (var k in dead) map.Remove(k);
        }

        // ---------- 턴 ----------

        /// <summary>적 턴 시작: 이번 아군 턴 효과(동남풍 · 고육계)와 쓰지 않은 예약·추가 이동 정리.</summary>
        public void OnEnemyTurnStart()
        {
            TimedEffects.RemoveAll(t => !t.EnemyWindow);
            PendingTeleport = null;
            foreach (var s in entries)
            {
                s.Reserved = false;
                s.Armed = false;
                s.BonusMovesLeft = 0;
                s.BonusAttack = false;
            }
        }

        /// <summary>아군 턴 시작: 이번 적 턴 효과(호위 · 철벽 · 간웅 · 일갈 · 안개)와 아군 견제 강화 정리.</summary>
        public void OnPlayerTurnStart()
        {
            TimedEffects.RemoveAll(t => t.EnemyWindow);
            foreach (var s in entries)
            {
                if (s.Unit == null || s.Unit.Faction != Faction.Player) continue;
                s.OwMult = 1f;
                s.OwAdd = 0f;
                s.OwUnlimited = false;
            }
        }

        public bool WindowActive(Timed t)
        {
            return !t.EnemyWindow || battle.Phase == BattlePhase.EnemyTurn;
        }

        // ---------- 액티브: 상태 · 탭 ----------

        public enum ActiveState
        {
            None,
            Ready,
            Reserved,
            Cooldown,
            Acted,
            BonusMove,
            NotTurn,
            Targeting
        }

        public ActiveState StateOf(Unit u)
        {
            var s = Of(u);
            if (u == null || s == null || !s.HasActive || u.Faction != Faction.Player || !u.IsAlive) return ActiveState.None;
            if (PendingTeleport == u) return ActiveState.Targeting;
            if (s.Reserved) return ActiveState.Reserved;
            if (battle.Phase != BattlePhase.PlayerTurn) return ActiveState.NotTurn;
            if (s.CooldownLeft(battle.TurnNumber) > 0) return ActiveState.Cooldown;
            if (s.Active.Trigger == SkillTrigger.NextAction)
            {
                if (u.BonusMoveAvailable) return ActiveState.BonusMove;
                if (!battle.CanAct(u)) return ActiveState.Acted;
            }
            return ActiveState.Ready;
        }

        /// <summary>HUD 스킬 버튼 탭: next_action = 예약/취소 · instant = 즉시 발동(변진 = 목표 지점 탭 대기). 반환 = 안내 문구.</summary>
        public string TapActive(Unit u)
        {
            var s = Of(u);
            var st = StateOf(u);
            switch (st)
            {
                case ActiveState.None: return null;
                case ActiveState.Targeting:
                    PendingTeleport = null;
                    return s.Active.NameKo + " 취소";
                case ActiveState.Reserved:
                    s.Reserved = false;
                    if (u.View != null) u.View.Refresh();
                    return s.Active.NameKo + " 예약 취소(쿨 소모 없음)";
                case ActiveState.NotTurn: return "아군 턴에만 쓸 수 있습니다";
                case ActiveState.Cooldown: return s.Active.NameKo + " — 쿨 " + s.CooldownLeft(battle.TurnNumber) + "턴";
                case ActiveState.Acted: return s.Active.NameKo + " — 이미 행동한 유닛";
                case ActiveState.BonusMove: return s.Active.NameKo + " — 추가 이동 중에는 예약할 수 없음";
            }
            if (s.Active.Trigger == SkillTrigger.NextAction)
            {
                s.Reserved = true;
                if (u.View != null) u.View.Refresh();
                return s.Active.NameKo + " 예약 — 다음 슬링샷에 발동 · 다시 탭 = 취소";
            }
            if (s.Active.First(SkillKeys.Teleport) != null)
            {
                PendingTeleport = u;
                return s.Active.NameKo + " — 반경 " + TeleportRadius(s).ToString("0.#") + " 안 빈 곳을 탭(다른 곳 = 취소)";
            }
            battle.RunSkillRoutine(Instant(s));
            return s.Active.NameKo + " 발동!";
        }

        // ---------- 행동 훅(ActionResolver.Resolve) ----------

        /// <summary>행동 시작: 예약한 next_action 효과를 장착(이동만인 추가 이동은 제외) · 발동 연출.</summary>
        public void BeginAction(Unit u, bool moveOnly, ActionOutcome o)
        {
            noted.Clear();
            var s = Of(u);
            if (s == null || !s.Reserved || !s.HasActive || moveOnly) return;
            s.Armed = true;
            o.SkillUsed = s.Active;
            Announce(s, s.Active);
        }

        /// <summary>행동 끝: 예약 소모 · 쿨(아군 턴 기준) · 견제 강화 이월.</summary>
        public void EndAction(Unit u, ActionOutcome o)
        {
            var s = Of(u);
            if (s == null || !s.Armed) return;
            if (o.Overwatch)
            {
                foreach (var e in s.ActiveEffects)
                {
                    if (e.Key == SkillKeys.OverwatchRadiusMult) s.OwMult *= e.P;
                    else if (e.Key == SkillKeys.OverwatchRadiusAdd) s.OwAdd += e.P;
                    else if (e.Key == SkillKeys.OverwatchUnlimited) s.OwUnlimited = true;
                }
            }
            s.Armed = false;
            s.Reserved = false;
            s.ReadyTurn = battle.TurnNumber + s.Active.Cooldown;
            if (u.View != null) u.View.Refresh();
        }

        /// <summary>조준 미리보기 동안만 예약 효과를 장착(사거리 · 사선 · 광역 표시). 반환 = 복원값.</summary>
        public bool PreviewBegin(Unit u)
        {
            var s = Of(u);
            if (s == null) return false;
            bool prev = s.Armed;
            if (s.Reserved && !u.BonusMoveAvailable) s.Armed = true;
            return prev;
        }

        public void PreviewEnd(Unit u, bool prev)
        {
            var s = Of(u);
            if (s != null) s.Armed = prev;
        }

        // ---------- 추가 이동 ----------

        public bool BonusCanAttack(Unit u)
        {
            var s = Of(u);
            return s != null && s.BonusAttack;
        }

        /// <summary>행동 뒤 추가 이동을 (또) 주는가 — 처음 명중 = 추가 이동 n 회(인덕) · 추가 이동 뒤 = 남은 횟수.</summary>
        public bool NextBonus(Unit u, bool wasBonus, ActionOutcome o)
        {
            var s = Of(u);
            if (!wasBonus)
            {
                if (!o.BonusMove) return false;
                if (s != null)
                {
                    s.BonusMovesLeft = Mathf.Max(0, o.BonusMoves - 1);
                    s.BonusAttack = o.BonusAttack;
                }
                return true;
            }
            if (s != null && s.BonusMovesLeft > 0)
            {
                s.BonusMovesLeft--;
                return true;
            }
            ClearBonus(u);
            return false;
        }

        public void ClearBonus(Unit u)
        {
            var s = Of(u);
            if (s == null) return;
            s.BonusMovesLeft = 0;
            s.BonusAttack = false;
        }

        // ---------- 적 턴: 교전 반응 · 교전 범위 ----------

        /// <summary>이번 적 턴에 교전 반응이 없는가(장판 일갈 공포 · 태평요술 안개).</summary>
        public bool Suppressed(Unit e)
        {
            if (e == null) return false;
            foreach (var t in TimedEffects)
            {
                if (!WindowActive(t)) continue;
                if (t.E.Key == SkillKeys.AoePushFear && t.Targets != null && t.Targets.Contains(e)) return true;
                if (t.E.Key == SkillKeys.EnemyAggroOffTurn && t.Faction != e.Faction) return true;
            }
            return false;
        }

        /// <summary>상대 진영 패시브(신산)가 actingFaction 의 교전 범위에 더하는 값.</summary>
        public float AggroAdd(Faction actingFaction)
        {
            float add = 0f;
            foreach (var s in entries)
            {
                if (s.Unit == null || !s.Unit.IsAlive || s.Unit.Faction == actingFaction || s.PassiveEffects == null) continue;
                foreach (var e in s.PassiveEffects)
                {
                    if (e.Key != SkillKeys.EnemyAggroAdd) continue;
                    add += e.P;
                    NotePassive(s, s.Passive);
                }
            }
            return add;
        }

        // ---------- 피해 적용(호위) ----------

        /// <summary>피해 적용 — 관평 호위(이번 적 턴 반경 안 같은 편 피해 일부를 관평이 대신) 반영. 반환 = d 가 실제 받은 피해.</summary>
        public int Hit(Unit d, int dmg)
        {
            if (d == null || !d.IsAlive || dmg <= 0) return 0;
            foreach (var t in TimedEffects)
            {
                if (t.E.Key != SkillKeys.GuardShare || !WindowActive(t)) continue;
                var g = t.Owner.Unit;
                if (g == null || !g.IsAlive || g == d || g.Faction != d.Faction) continue;
                float r = t.E.HasA2 ? t.E.A2 : 0f;
                if (Vector2.Distance(g.Position, d.Position) > r + d.Radius) continue;
                int share = Mathf.Clamp(Mathf.RoundToInt(dmg * Mathf.Clamp01(t.E.P)), 0, dmg);
                if (share <= 0) continue;
                g.TakeDamage(share);
                Fx.Popup(g.Position, share + " 호위", SkillFx.GuardColor);
                dmg -= share;
                break;
            }
            d.TakeDamage(dmg);
            return dmg;
        }

        /// <summary>스킬 시스템이 없어도 쓰는 피해 적용.</summary>
        public static int Deal(Unit d, int dmg)
        {
            if (Current != null) return Current.Hit(d, dmg);
            if (d == null) return 0;
            d.TakeDamage(dmg);
            return dmg;
        }

        // ---------- 즉시형 액티브 ----------

        /// <summary>즉시 발동(행동 소모 없음): 효과마다 처리 → 쿨.</summary>
        public IEnumerator Instant(UnitSkills s)
        {
            var u = s.Unit;
            Announce(s, s.Active);
            s.ReadyTurn = battle.TurnNumber + s.Active.Cooldown;
            foreach (var e in s.ActiveEffects)
            {
                switch (e.Key)
                {
                    case SkillKeys.AoePushFear:
                        yield return PushFear(s, e);
                        break;
                    case SkillKeys.HpCostAtk:
                        PayHp(u, e.HasA2 ? e.A2 : 0f);
                        AddTimed(s, e, false, null);
                        break;
                    case SkillKeys.GuardShare:
                    case SkillKeys.TeamDmgTakenPctTurn:
                    case SkillKeys.DmgTakenAura:
                    case SkillKeys.EnemyAggroOffTurn:
                        AddTimed(s, e, true, null);
                        break;
                    case SkillKeys.Teleport:
                        break; // 목표 지점 탭(TryTeleport)
                    default:
                        AddTimed(s, e, false, null); // 동남풍(sling_dist_pct) 등 = 이번 아군 턴
                        break;
                }
            }
            yield return Fx.Wait(0.25f);
            battle.NotifyChanged();
        }

        void AddTimed(UnitSkills s, SkillEffect e, bool enemyWindow, HashSet<Unit> targets)
        {
            TimedEffects.Add(new Timed { Owner = s, Faction = s.Unit.Faction, Def = s.Active, E = e, EnemyWindow = enemyWindow, Targets = targets });
        }

        static void PayHp(Unit u, float ratio)
        {
            int cost = Mathf.RoundToInt(u.MaxHp * Mathf.Max(0f, ratio));
            if (cost <= 0) return;
            u.Hp = Mathf.Max(1, u.Hp - cost); // 스스로 쓰러지지는 않는다
            if (u.View != null)
            {
                u.View.OnHit();
                u.View.Refresh();
            }
            Fx.Popup(u.Position, "HP −" + cost, SkillFx.CostColor);
        }

        /// <summary>장판 일갈: 반경(p2) 안 상대 전원을 바깥으로 p1 밀고 이번 적 턴 교전 반응 없음.</summary>
        IEnumerator PushFear(UnitSkills s, SkillEffect e)
        {
            var u = s.Unit;
            float radius = e.HasA2 ? e.A2 : 0f;
            var targets = new HashSet<Unit>();
            int running = 0;
            Faction other = u.Faction == Faction.Player ? Faction.Enemy : Faction.Player;
            foreach (var t in battle.AliveUnits(other))
            {
                if (Vector2.Distance(u.Position, t.Position) > radius + t.Radius) continue;
                targets.Add(t);
                Vector2 dir = t.Position - u.Position;
                dir = dir.sqrMagnitude > 1e-6f ? dir.normalized : Vector2.up;
                float force = e.P * SkillMods.KnockbackTakenMult(t, true);
                float slide = Combat.FreeTravel(t, t.Position, dir, force, true, true, u);
                if (slide <= 0.01f) continue;
                Vector2 end = battle.Board.ClampInside(t.Position + dir * slide, t.Radius);
                running++;
                var unit = t;
                if (unit.View != null) unit.View.SetFacing(dir);
                Fx.Run(Track(Fx.MoveAlong(unit.transform, unit.Position, end, battle.Config.moveSpeed, null), () =>
                {
                    unit.Position = end;
                    running--;
                }));
            }
            Fx.Burst(u.Position, radius, SkillFx.FearColor);
            while (running > 0) yield return null;
            var t2 = new Timed { Owner = s, Faction = u.Faction, Def = s.Active, E = e, EnemyWindow = true, Targets = targets };
            TimedEffects.Add(t2);
            battle.NotifyChanged();
        }

        static IEnumerator Track(IEnumerator inner, System.Action onDone)
        {
            yield return inner;
            onDone();
        }

        // ---------- 변진(장합): 목표 지점 탭 ----------

        public static float TeleportRadius(UnitSkills s)
        {
            if (s == null || s.ActiveEffects == null) return 0f;
            foreach (var e in s.ActiveEffects)
                if (e.Key == SkillKeys.Teleport) return e.P;
            return 0f;
        }

        /// <summary>목표 지점이 반경 안 빈 곳인가(벽·유닛과 겹치지 않음 · 전장 안).</summary>
        public bool TeleportValid(Unit u, Vector2 w)
        {
            var s = Of(u);
            if (s == null) return false;
            if (Vector2.Distance(u.Position, w) > TeleportRadius(s) + 1e-3f) return false;
            if ((battle.Board.ClampInside(w, u.Radius) - w).sqrMagnitude > 1e-4f) return false;
            Physics2D.SyncTransforms();
            foreach (var c in Physics2D.OverlapCircleAll(w, u.Radius))
            {
                if (c.GetComponent<BoardWall>() != null) return false;
                var o = c.GetComponent<Unit>();
                if (o != null && o != u && o.IsAlive) return false;
            }
            return true;
        }

        /// <summary>변진 대기 중 화면 탭 → 처리했으면 true(유효 = 이동 · 아니면 취소).</summary>
        public bool TryTeleportTap(Vector2 w, out string message)
        {
            message = null;
            var u = PendingTeleport;
            if (u == null) return false;
            PendingTeleport = null;
            var s = Of(u);
            if (s == null || !u.IsAlive || battle.Phase != BattlePhase.PlayerTurn) return true;
            if (!TeleportValid(u, w))
            {
                message = s.Active.NameKo + " 취소 — 반경 안 빈 곳이 아님";
                return true;
            }
            battle.RunSkillRoutine(TeleportRoutine(s, w));
            message = s.Active.NameKo + " 발동!";
            return true;
        }

        public IEnumerator TeleportRoutine(UnitSkills s, Vector2 w)
        {
            var u = s.Unit;
            Announce(s, s.Active);
            s.ReadyTurn = battle.TurnNumber + s.Active.Cooldown;
            if (u.View != null) u.View.SetFacing(w - u.Position);
            yield return Fx.MoveAlong(u.transform, u.Position, w, battle.Config.moveSpeed * 2f, null);
            u.Position = w;
            battle.NotifyChanged();
        }

        // ---------- 연출 · HUD 기록 ----------

        /// <summary>액티브 발동 = 유닛 위 스킬 이름 + 플래시 + HUD 한 줄.</summary>
        public void Announce(UnitSkills s, SkillDef def)
        {
            if (s == null || def == null) return;
            if (s.Unit != null) SkillFx.Announce(s.Unit, def.NameKo);
            AddLog("액티브 · " + (s.Unit != null ? s.Unit.DisplayName : "") + " 「" + def.NameKo + "」");
        }

        /// <summary>패시브 발동 HUD 한 줄(같은 행동 안에서는 스킬마다 1번).</summary>
        public void NotePassive(UnitSkills s, SkillDef def)
        {
            if (s == null || def == null || s.Unit == null) return;
            string key = s.Unit.GetInstanceID() + "/" + def.Id;
            if (!noted.Add(key)) return;
            AddLog("패시브 · " + s.Unit.DisplayName + " 「" + def.NameKo + "」");
        }

        public void AddLog(string text)
        {
            Log.Add(new LogLine { Text = text, Time = Time.unscaledTime });
            if (Log.Count > 8) Log.RemoveAt(0);
        }

        /// <summary>최근 seconds 초 안의 기록(최신이 마지막).</summary>
        public List<string> RecentLog(float seconds, int max)
        {
            var res = new List<string>();
            float now = Time.unscaledTime;
            for (int i = Log.Count - 1; i >= 0 && res.Count < max; i--)
                if (now - Log[i].Time <= seconds) res.Insert(0, Log[i].Text);
            return res;
        }
    }

    /// <summary>스킬 연출(이름 글자 · 플래시).</summary>
    public static class SkillFx
    {
        public static readonly Color NameColor = new Color(1f, 0.85f, 0.3f);
        public static readonly Color FlashColor = new Color(1f, 0.9f, 0.45f, 0.55f);
        public static readonly Color GuardColor = new Color(0.55f, 0.85f, 1f);
        public static readonly Color FearColor = new Color(1f, 0.4f, 0.25f, 0.4f);
        public static readonly Color CostColor = new Color(1f, 0.55f, 0.35f);
        public static readonly Color HealColor = new Color(0.45f, 1f, 0.5f);

        public static void Announce(Unit u, string name)
        {
            Fx.Burst(u.Position, u.Radius * 2.2f, FlashColor);
            Fx.Run(NameRoutine(u.Position + new Vector2(0f, u.ArtHeight > 0f ? u.ArtHeight * 0.6f : u.Radius + 0.6f), name));
        }

        static IEnumerator NameRoutine(Vector2 pos, string text)
        {
            var tm = TextUtil.CreateWorldText(null, text, 0.55f, NameColor, 21);
            tm.gameObject.name = "SkillName";
            var tr = tm.transform;
            float t = 0f;
            const float dur = 1.1f;
            while (t < dur)
            {
                t += Time.deltaTime;
                float k = Mathf.Clamp01(t / dur);
                tr.position = new Vector3(pos.x, pos.y + 0.4f * k, 0f);
                var c = NameColor;
                c.a = k < 0.7f ? 1f : 1f - (k - 0.7f) / 0.3f;
                tm.color = c;
                yield return null;
            }
            Object.Destroy(tm.gameObject);
        }
    }
}