// WL813i_Probe.cs — #813i(무적 해제 게이트 · 물약 · 사망/부활) 에디트 모드 검증 프로브
//   에디트 모드 전용 · Play 불필요 · 로그인 0 · 에셋/씬/TimeManager 무수정(런타임 클론 SO 를 리플렉션으로 주입 · 임시 오브젝트 즉시 파괴)
//
//   상주 에디터: unity command run_script --project-path <wt> --file AgentScripts/WL813i_Probe.cs --entry WL813i_Probe.RunAll
//   결과: Console + AgentScripts/WL813i_PROBE.txt(커밋) + Screenshots_WL/WL813i/probe_<HHmmss>.txt (RESULT PASS / RESULT FAIL n)
//
//   검사(발주서 WL-813i ⓒ · ⓓ)
//     ① 에셋: 디스크 enabled=0(C8 기본) · 값 덤프 · RuntimeOverride
//     ② C8: SO off 면 TakeDamage=base 그대로(피해·플래그 무변경) · TryUse=Disabled · OnPCDied 무시
//     ③ 무적 해제 게이트: 잡몹 ×0.5 · 보스 ×배율 · 스위치 off 통과 · 정예 취급 · 적 PC 통과 · 호출 중 플래그 false → 뒤 true 복원 · 예외에도 복원 · 부활 무적 창 통과 · GC
//     ④ 물약: 3회/쿨 5 s/만충 거절/빈 통/사망/NoPC · 잔량·쿨 이벤트 · 런 리셋
//     ⑤ 사망/부활: 연출 2 s → ReviveRequested → Revive() → Revived + 무적 1.5 s · 구독자 0 자동 부활 · 외부 부활 감지 · 조기 응답 · 타임아웃 · Abort · 중복 사망 · 적 PC
//     ⑥ 이벤트 GC 0 · ⑦ 정리(클론 파괴 · 캐시 복구 · 씬 dirty)
//
//   에디트 모드 한계: Time.timeScale 은 읽기만(대입하면 TimeManager.asset 에 적힌다 · 811b-fix 실측) — DeathFlow 가 Application.isPlaying 으로 스스로 막는다.
//   부활 실행(On_Regen → LoadMapMgr/ActorInfo)은 에디트 모드에 없어 DeathFlow.ReviveOverride 로 바꿔치기한다(런타임 On_Regen 경로 = 병합 후 QA).

using System;
using System.IO;
using System.Reflection;
using System.Text;
using UnityEngine;
using WL.Combat.Core;
using WL.Combat.Survival;

public static class WL813i_Probe
{
    const string OutDir = "Screenshots_WL/WL813i";
    const string OutCommit = "AgentScripts/WL813i_PROBE.txt";
    const BindingFlags NP = BindingFlags.NonPublic | BindingFlags.Instance;

    static WLSurvivalSettings s_clone;

    public static object RunAll()
    {
        var sb = new StringBuilder();
        sb.AppendLine("# WL813i Probe " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + " (edit mode · Play 0)");
        int fail = 0;
        float ts0 = Time.timeScale;
        try { fail += Asset(sb); } catch (Exception ex) { fail++; sb.AppendLine("[FAIL] ① 예외 " + ex); }
        try { fail += C8(sb); } catch (Exception ex) { fail++; sb.AppendLine("[FAIL] ② 예외 " + ex); }
        try { fail += DamageGate(sb); } catch (Exception ex) { fail++; sb.AppendLine("[FAIL] ③ 예외 " + ex); }
        try { fail += Potion(sb); } catch (Exception ex) { fail++; sb.AppendLine("[FAIL] ④ 예외 " + ex); }
        try { fail += Death(sb); } catch (Exception ex) { fail++; sb.AppendLine("[FAIL] ⑤ 예외 " + ex); }
        try { fail += EventGc(sb); } catch (Exception ex) { fail++; sb.AppendLine("[FAIL] ⑥ 예외 " + ex); }
        try { fail += Cleanup(sb, ts0); } catch (Exception ex) { fail++; sb.AppendLine("[FAIL] ⑦ 예외 " + ex); }
        sb.AppendLine(fail == 0 ? "RESULT PASS" : "RESULT FAIL " + fail);
        var s = sb.ToString();
        Debug.Log(s);
        try
        {
            Directory.CreateDirectory(OutDir);
            File.WriteAllText(Path.Combine(OutDir, "probe_" + DateTime.Now.ToString("HHmmss") + ".txt"), s);
            File.WriteAllText(OutCommit, s);
        }
        catch { /* 출력 저장 실패는 판정에 영향 없음 */ }
        return s;
    }

    // ───────────────────────────────────────── 도구
    static string P(bool ok) { return ok ? "[PASS]" : "[FAIL]"; }
    /// <summary>원본 Heal(float rate) 은 0.4f 를 double 로 넓혀 곱하므로(400.000006) 1e-3 허용.</summary>
    static bool Near(double a, double b) { return Math.Abs(a - b) < 1e-3; }

    /// <summary>Unity Mono 의 GC.GetAllocatedBytesForCurrentThread 는 상수를 돌려준다(실측 · 대조군 0 B) → GetTotalMemory(4 KB 페이지 단위) + 대조군으로 감도를 보인다(813k 선례).</summary>
    static long Alloc() { return GC.GetTotalMemory(false); }
    static long Mono() { return UnityEngine.Profiling.Profiler.GetMonoUsedSizeLong(); }

    /// <summary>디스크 에셋을 건드리지 않는 런타임 클론을 WLSurvivalSettings 캐시에 주입한다(값 변경 실험용).</summary>
    static WLSurvivalSettings UseClone()
    {
        var orig = WLSurvivalSettings.Instance;
        if (orig == null) return null;
        if (s_clone == null)
        {
            s_clone = UnityEngine.Object.Instantiate(orig);
            s_clone.hideFlags = HideFlags.HideAndDontSave;
            s_clone.name = "WLSurvivalSettings(probe clone)";
        }
        var fc = typeof(WLSurvivalSettings).GetField("s_cached", BindingFlags.NonPublic | BindingFlags.Static);
        var fd = typeof(WLSurvivalSettings).GetField("s_lookupDone", BindingFlags.NonPublic | BindingFlags.Static);
        if (fc == null || fd == null) return null;
        fc.SetValue(null, s_clone); fd.SetValue(null, true);
        return s_clone;
    }

    static void RestoreAsset()
    {
        WLSurvivalSettings.ClearCache();
        WLSurvivalSettings.RuntimeOverride = 0;
    }

    static PCActor MakePC(string name, double maxHp, double hp, bool enemy = false)
    {
        var go = new GameObject("__WL813i_" + name);
        var pc = go.AddComponent<PCActor>();
        pc.m_Role = eRole.PC; pc.m_SubRole = eSubRol.None;
        var stat = new ActorStatInfo(eRole.PC);
        stat.Set_Stat(eStat.MaxHP, maxHp); stat.Set_Stat(eStat.HP, hp);
        typeof(Actor).GetField("m_Stat", NP).SetValue(pc, stat);
        typeof(Actor).GetField("m_Enemy", NP).SetValue(pc, enemy);
        return pc;
    }

    static Actor MakeBeater(string name, eSubRol sub)
    {
        var go = new GameObject("__WL813i_" + name);
        var a = go.AddComponent<Actor>();
        a.m_Role = eRole.Mob; a.m_SubRole = sub;
        typeof(Actor).GetField("m_Enemy", NP).SetValue(a, true);
        return a;
    }

    static void SetDead(Actor a, bool dead) { typeof(Actor).GetField("DeadStatus", NP).SetValue(a, dead); }
    static bool IsDead(Actor a) { return (bool)typeof(Actor).GetField("DeadStatus", NP).GetValue(a); }
    static void SetHp(Actor a, double hp) { a.Get_StatInfo().Set_Stat(eStat.HP, hp); }

    static void Kill(params UnityEngine.Object[] objs)
    {
        foreach (var o in objs)
        {
            if (o == null) continue;
            var c = o as Component;
            UnityEngine.Object.DestroyImmediate(c != null ? c.gameObject : o);
        }
    }

    // ── 가짜 base.Get_Damage(MyActor 대역): 호출 수 · 호출 시점의 피해값 · 무적 플래그를 기록한다
    static int s_baseCalls; static double s_baseDamage; static bool s_baseFlag; static bool s_baseThrow;
    static void FakeBase(DamageInfo d)
    {
        s_baseCalls++; s_baseDamage = d != null ? d.Damage : -1d;
        s_baseFlag = WL.Settings.WLGameplaySettings.PlayerInvincible;
        if (s_baseThrow) throw new InvalidOperationException("probe: base threw");
    }
    static readonly Action<DamageInfo> s_fake = FakeBase;

    static DamageInfo Dmg(Actor beater, double dmg) { var d = new DamageInfo(); d.Beater = beater; d.Damage = dmg; return d; }

    // ───────────────────────────────────────── ① 에셋
    static int Asset(StringBuilder sb)
    {
        RestoreAsset();
        var st = WLSurvivalSettings.Instance;
        var gs = WL.Settings.WLGameplaySettings.Instance;
        sb.AppendLine("survival asset=" + (st != null ? "found" : "NULL") + " enabled(disk)=" + (st != null && st.enabled)
            + " Enabled=" + WLSurvivalSettings.Enabled + " · gameplay asset=" + (gs != null ? "found" : "NULL")
            + " playerInvincible(disk)=" + (gs != null && gs.playerInvincible) + " · core Enabled=" + WLCombatCoreSettings.Enabled);
        if (st == null) { sb.AppendLine("[FAIL] ① WLSurvivalSettings.asset 로드 실패"); return 1; }
        sb.AppendLine("  values: mob " + st.takeMobDamage + "×" + st.mobDamageMultiplier + " boss " + st.takeBossDamage + "×" + st.bossDamageMultiplier
            + " eliteAsBoss=" + st.eliteCountsAsBoss + " · potion " + st.potionCountPerRun + "/run " + st.potionHealRate + " cd " + st.potionCooldownSeconds
            + " showHeal=" + st.potionShowHealNumber + " refuseFull=" + st.potionRefuseAtFullHp + " resetOnMap=" + st.potionResetOnMapLoad
            + " · death display " + st.deathDisplaySeconds + " hold=" + st.holdWorldWhileReviving + " autoNoListener=" + st.autoReviveWhenNoListener
            + " timeout=" + st.autoReviveTimeoutSeconds + " invincible " + st.reviveInvincibleSeconds + " heal " + st.reviveHealRate + " companions=" + st.reviveCompanions);
        bool diskOff = !st.enabled && !WLSurvivalSettings.Enabled;
        WLSurvivalSettings.RuntimeOverride = 1; bool forceOn = WLSurvivalSettings.Enabled;
        WLSurvivalSettings.RuntimeOverride = -1; bool forceOff = !WLSurvivalSettings.Enabled;
        WLSurvivalSettings.RuntimeOverride = 0;
        bool ok = diskOff && forceOn && forceOff && gs != null && gs.playerInvincible;
        sb.AppendLine(P(ok) + " ① C8 기본: enabled(disk)=false✔ Enabled=false · RuntimeOverride 1→" + forceOn + " -1→off " + forceOff + " · playerInvincible 유지 " + (gs != null && gs.playerInvincible));
        return ok ? 0 : 1;
    }

    // ───────────────────────────────────────── ② C8 통과
    static int C8(StringBuilder sb)
    {
        RestoreAsset();
        Survival.ResetDiagnostics(); PotionUse.ResetDiagnostics(); DeathFlow.ResetDiagnostics();
        var pc = MakePC("pc", 1000, 300); var mob = MakeBeater("mob", eSubRol.None);
        try
        {
            s_baseCalls = 0;
            var d = Dmg(mob, 100);
            Survival.TakeDamage(pc, d, s_fake);
            bool a = s_baseCalls == 1 && Math.Abs(s_baseDamage - 100d) < 1e-9 && s_baseFlag && Survival.PassDisabled == 1 && Survival.Applied == 0;
            var r = PotionUse.TryUse(pc);
            bool b = r == PotionResult.Disabled && PotionUse.Changed.Raised == 0 && Math.Abs(pc.Get_HP() - 300d) < 1e-9;
            SetDead(pc, true);
            DeathFlow.OnPCDied(pc);
            bool c = DeathFlow.State == DeathState.None && DeathFlow.Died.Raised == 0 && DeathFlow.DeathCount == 0;
            SetDead(pc, false);
            bool ok = a && b && c;
            sb.AppendLine(P(ok) + " ② C8(SO off): TakeDamage→base 1회 dmg=" + s_baseDamage + " flag=" + s_baseFlag + " PassDisabled=" + Survival.PassDisabled
                + " · TryUse=" + r + " Changed=" + PotionUse.Changed.Raised + " hp=" + pc.Get_HP() + " · OnPCDied state=" + DeathFlow.State + " Died=" + DeathFlow.Died.Raised);
            return ok ? 0 : 1;
        }
        finally { Kill(pc, mob); }
    }

    // ───────────────────────────────────────── ③ 무적 해제 게이트
    static int DamageGate(StringBuilder sb)
    {
        var st = UseClone(); if (st == null) { sb.AppendLine("[FAIL] ③ 클론 주입 실패"); return 1; }
        st.enabled = true; st.verboseLog = false;
        st.takeMobDamage = true; st.mobDamageMultiplier = 0.5f; st.takeBossDamage = true; st.bossDamageMultiplier = 0.25f; st.eliteCountsAsBoss = false;
        Survival.ResetDiagnostics();
        var gs = WL.Settings.WLGameplaySettings.Instance;
        bool flagBefore = WL.Settings.WLGameplaySettings.PlayerInvincible;
        var pc = MakePC("pc", 1000, 500); var enemyPc = MakePC("enemyPc", 1000, 500, true);
        var mob = MakeBeater("mob", eSubRol.None); var boss = MakeBeater("boss", eSubRol.Boss); var elite = MakeBeater("elite", eSubRol.Elite);
        int fails = 0;
        try
        {
            // a) 잡몹 ×0.5 · 호출 중 플래그 false · 뒤 복원
            s_baseCalls = 0; var d = Dmg(mob, 100); Survival.TakeDamage(pc, d, s_fake);
            bool a = s_baseCalls == 1 && Math.Abs(s_baseDamage - 50d) < 1e-9 && !s_baseFlag && WL.Settings.WLGameplaySettings.PlayerInvincible == flagBefore
                     && Survival.Applied == 1 && Survival.Lifted == (flagBefore ? 1 : 0) && !Survival.LastWasBoss;
            sb.AppendLine(P(a) + " ③a 잡몹 100→base " + s_baseDamage + " (기대 50) flagDuring=" + s_baseFlag + " flagAfter=" + WL.Settings.WLGameplaySettings.PlayerInvincible + " (기대 " + flagBefore + ") Lifted=" + Survival.Lifted);
            if (!a) fails++;

            // b) 보스 ×0.25
            s_baseCalls = 0; d = Dmg(boss, 100); Survival.TakeDamage(pc, d, s_fake);
            bool b = s_baseCalls == 1 && Math.Abs(s_baseDamage - 25d) < 1e-9 && !s_baseFlag && Survival.LastWasBoss && WL.Settings.WLGameplaySettings.PlayerInvincible == flagBefore;
            sb.AppendLine(P(b) + " ③b 보스 100→base " + s_baseDamage + " (기대 25) boss=" + Survival.LastWasBoss);
            if (!b) fails++;

            // c) 보스 스위치 off → 원본 그대로(피해 100 · 플래그 true 유지)
            st.takeBossDamage = false;
            s_baseCalls = 0; d = Dmg(boss, 100); Survival.TakeDamage(pc, d, s_fake);
            bool c = s_baseCalls == 1 && Math.Abs(s_baseDamage - 100d) < 1e-9 && s_baseFlag == flagBefore && Survival.SkippedBossSwitch == 1;
            sb.AppendLine(P(c) + " ③c 보스 스위치 off: base dmg=" + s_baseDamage + " (기대 100) flagDuring=" + s_baseFlag + " SkippedBossSwitch=" + Survival.SkippedBossSwitch);
            if (!c) fails++;
            st.takeBossDamage = true;

            // d) 정예: 기본 잡몹 취급(×0.5) · eliteCountsAsBoss → ×0.25
            s_baseCalls = 0; d = Dmg(elite, 100); Survival.TakeDamage(pc, d, s_fake); double e1 = s_baseDamage;
            st.eliteCountsAsBoss = true;
            s_baseCalls = 0; d = Dmg(elite, 100); Survival.TakeDamage(pc, d, s_fake); double e2 = s_baseDamage;
            st.eliteCountsAsBoss = false;
            bool dd = Math.Abs(e1 - 50d) < 1e-9 && Math.Abs(e2 - 25d) < 1e-9;
            sb.AppendLine(P(dd) + " ③d 정예: 기본 " + e1 + " (기대 50) · eliteCountsAsBoss " + e2 + " (기대 25)");
            if (!dd) fails++;

            // e) 잡몹 스위치 off + 적 PC 통과
            st.takeMobDamage = false;
            s_baseCalls = 0; d = Dmg(mob, 100); Survival.TakeDamage(pc, d, s_fake); bool e_mob = s_baseDamage == 100d && Survival.SkippedMobSwitch == 1;
            st.takeMobDamage = true;
            s_baseCalls = 0; d = Dmg(mob, 100); Survival.TakeDamage(enemyPc, d, s_fake); bool e_pc = s_baseDamage == 100d && Survival.PassNotMainPC == 1 && s_baseFlag == flagBefore;
            bool e = e_mob && e_pc;
            sb.AppendLine(P(e) + " ③e 잡몹 스위치 off 통과=" + e_mob + " (SkippedMobSwitch=" + Survival.SkippedMobSwitch + ") · 적 PC 통과=" + e_pc + " (PassNotMainPC=" + Survival.PassNotMainPC + ")");
            if (!e) fails++;

            // f) base 예외 → finally 복원
            s_baseThrow = true; bool threw = false;
            try { Survival.TakeDamage(pc, Dmg(mob, 100), s_fake); } catch (InvalidOperationException) { threw = true; }
            s_baseThrow = false;
            bool f = threw && WL.Settings.WLGameplaySettings.PlayerInvincible == flagBefore;
            sb.AppendLine(P(f) + " ③f base 예외 후 플래그 복원: threw=" + threw + " flag=" + WL.Settings.WLGameplaySettings.PlayerInvincible + " (기대 " + flagBefore + ")");
            if (!f) fails++;

            // g) 부활 무적 창(게임 시간 클록)
            Survival.Tick(10f); Survival.SetReviveInvincible(pc, 1.5f);
            bool g1 = Survival.IsReviveInvincible(pc) && Math.Abs(Survival.ReviveInvincibleRemaining - 1.5f) < 1e-4f;
            s_baseCalls = 0; Survival.TakeDamage(pc, Dmg(mob, 100), s_fake);
            bool g2 = s_baseCalls == 1 && s_baseDamage == 100d && s_baseFlag == flagBefore && Survival.BlockedReviveInvincible == 1;
            Survival.Tick(11.49f); bool g3 = Survival.IsReviveInvincible(pc);
            Survival.Tick(11.5f); bool g4 = !Survival.IsReviveInvincible(pc);
            s_baseCalls = 0; Survival.TakeDamage(pc, Dmg(mob, 100), s_fake); bool g5 = s_baseDamage == 50d;
            bool g6 = !Survival.IsReviveInvincible(enemyPc);
            bool g = g1 && g2 && g3 && g4 && g5 && g6;
            sb.AppendLine(P(g) + " ③g 부활 무적 1.5 s: 창 안 통과(dmg " + (g2 ? "100" : s_baseDamage.ToString()) + " Blocked=" + Survival.BlockedReviveInvincible + ") · t+1.49 " + g3 + " · t+1.5 해제 " + g4 + " → 배율 재적용 " + g5 + " · 다른 PC " + g6);
            if (!g) fails++;

            // h) GC: 힙 크기 델타는 페이지 단위·수집 시점에 좌우되므로 100만 회(할당 시 32 MB) + GC.CollectionCount 로 판정하고,
            //    델리게이트·대조군은 배열에 살려 둔 채(100k · 수집 불가) 힙 델타로 개당 비용을 잰다.
            var dd2 = Dmg(mob, 100);
            for (int i = 0; i < 20; i++) { dd2.Damage = 100; Survival.TakeDamage(pc, dd2, s_fake); }
            GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect();
            int gc0 = GC.CollectionCount(0); long a0 = Alloc(), p0 = Mono();
            for (int i = 0; i < 1000000; i++) { dd2.Damage = 100; Survival.TakeDamage(pc, dd2, s_fake); }
            long a1 = Alloc(), p1 = Mono(); int gc1 = GC.CollectionCount(0);
            const int N = 100000;
            var keepArr = new Action<DamageInfo>[N];
            GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect();
            long b0 = Alloc(), q0 = Mono();
            for (int i = 0; i < N; i++) keepArr[i] = new Action<DamageInfo>(mob.Get_Damage);
            long b1 = Alloc(), q1 = Mono();
            var objArr = new object[N];
            GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect();
            long c0 = Alloc(), r0 = Mono();
            for (int i = 0; i < N; i++) objArr[i] = new object();
            long c1 = Alloc(), r1 = Mono();
            bool sensitive = (c1 - c0) > 0L || (r1 - r0) > 0L;
            bool h = a1 - a0 == 0L && p1 - p0 == 0L && gc1 == gc0 && sensitive && keepArr[N - 1] != null && objArr[N - 1] != null;
            sb.AppendLine(P(h) + " ③h GC: TakeDamage×1,000,000 = 힙 " + (a1 - a0) + " B / mono " + (p1 - p0) + " B / 수집 " + (gc1 - gc0) + "회 (기대 0/0/0)"
                + " · 훅 줄 델리게이트 ×100k(보존) = " + (b1 - b0) + " B / mono " + (q1 - q0) + " B (≈" + (Math.Max(b1 - b0, q1 - q0) / N) + " B/피격)"
                + " · 대조군 new object()×100k(보존) = " + (c1 - c0) + " B / mono " + (r1 - r0) + " B (감도 " + sensitive + ")");
            keepArr = null; objArr = null;
            if (!h) fails++;
        }
        finally { Kill(pc, enemyPc, mob, boss, elite); if (gs != null) gs.playerInvincible = flagBefore; }
        return fails;
    }

    // ───────────────────────────────────────── ④ 물약
    static int Potion(StringBuilder sb)
    {
        var st = UseClone(); if (st == null) { sb.AppendLine("[FAIL] ④ 클론 주입 실패"); return 1; }
        st.enabled = true; st.potionCountPerRun = 3; st.potionHealRate = 0.4f; st.potionCooldownSeconds = 5f; st.potionShowHealNumber = false; st.potionRefuseAtFullHp = true;
        PotionUse.ResetDiagnostics();
        int changed = 0, used = 0, cdEnded = 0, refused = 0; PotionResult lastRefuse = PotionResult.Used;
        CombatHandler<PotionEvent> onChanged = (in PotionEvent e) => { changed++; if (e.change == PotionChange.CooldownEnded) cdEnded++; if (e.change == PotionChange.Refused) { refused++; lastRefuse = e.result; } };
        CombatHandler<PotionEvent> onUsed = (in PotionEvent e) => { used++; };
        PotionUse.Changed.Add(onChanged); PotionUse.Used.Add(onUsed);
        var pc = MakePC("pc", 1000, 300);
        int fails = 0;
        try
        {
            PotionUse.Tick(0f);
            bool a0 = PotionUse.Remaining == 3 && PotionUse.Max == 3 && PotionUse.IsReady;
            var r1 = PotionUse.TryUse(pc);
            bool a = a0 && r1 == PotionResult.Used && Near(pc.Get_HP(), 700d) && PotionUse.Remaining == 2 && Math.Abs(PotionUse.CooldownRemaining - 5f) < 1e-4f && !PotionUse.IsReady && used == 1 && changed == 1;
            sb.AppendLine(P(a) + " ④a 사용 1: " + r1 + " hp 300→" + pc.Get_HP() + " (기대 700) remaining=" + PotionUse.Remaining + " cd=" + PotionUse.CooldownRemaining.ToString("F2") + " IsReady=" + PotionUse.IsReady);
            if (!a) fails++;

            var r2 = PotionUse.TryUse(pc);
            PotionUse.Tick(4.99f); int cd1 = cdEnded;
            PotionUse.Tick(5f); int cd2 = cdEnded;
            bool b = r2 == PotionResult.Cooldown && lastRefuse == PotionResult.Cooldown && cd1 == 0 && cd2 == 1 && PotionUse.IsReady && Near(pc.Get_HP(), 700d);
            sb.AppendLine(P(b) + " ④b 쿨 중 거절=" + r2 + " · t=4.99 CooldownEnded=" + cd1 + " · t=5.0 CooldownEnded=" + cd2 + " IsReady=" + PotionUse.IsReady);
            if (!b) fails++;

            var r3 = PotionUse.TryUse(pc);                        // 700 + 400 → 1000(클램프)
            bool c = r3 == PotionResult.Used && Near(pc.Get_HP(), 1000d) && PotionUse.Remaining == 1;
            PotionUse.Tick(10f);
            var r4 = PotionUse.TryUse(pc);                        // 만충 거절 · 개수 유지
            bool c2 = r4 == PotionResult.FullHp && PotionUse.Remaining == 1;
            sb.AppendLine(P(c && c2) + " ④c 사용 2: " + r3 + " hp=" + pc.Get_HP() + " (기대 1000 클램프) remaining=" + PotionUse.Remaining + " · 만충 거절=" + r4 + " remaining 유지=" + (PotionUse.Remaining == 1));
            if (!(c && c2)) fails++;

            SetHp(pc, 100);
            var r5 = PotionUse.TryUse(pc);                        // 3회째
            bool d = r5 == PotionResult.Used && Near(pc.Get_HP(), 500d) && PotionUse.Remaining == 0 && !PotionUse.IsReady;
            PotionUse.Tick(20f);
            var r6 = PotionUse.TryUse(pc);
            bool d2 = r6 == PotionResult.Empty && PotionUse.Remaining == 0 && used == 3;
            sb.AppendLine(P(d && d2) + " ④d 사용 3: " + r5 + " hp=" + pc.Get_HP() + " (기대 500) remaining=" + PotionUse.Remaining + " · 빈 통=" + r6 + " Used 이벤트=" + used + " (기대 3)");
            if (!(d && d2)) fails++;

            int chBefore = changed;
            PotionUse.ResetRun("probe");
            int chReset = changed - chBefore;
            bool e = PotionUse.Remaining == 3 && PotionUse.IsReady && chReset == 1 && PotionUse.RunResets == 1;
            SetDead(pc, true); var r7 = PotionUse.TryUse(pc); SetDead(pc, false);
            var r8 = PotionUse.TryUse(null);
            bool e2 = r7 == PotionResult.Dead && r8 == PotionResult.NoPC && PotionUse.Remaining == 3;
            sb.AppendLine(P(e && e2) + " ④e 런 리셋: remaining=" + PotionUse.Remaining + " Changed(RunReset)=" + chReset + " · 사망=" + r7 + " · NoPC=" + r8 + " · Changed 총=" + changed + " refused=" + refused);
            if (!(e && e2)) fails++;
        }
        finally { PotionUse.Changed.Remove(onChanged); PotionUse.Used.Remove(onUsed); Kill(pc); }
        return fails;
    }

    // ───────────────────────────────────────── ⑤ 사망/부활
    static int Death(StringBuilder sb)
    {
        var st = UseClone(); if (st == null) { sb.AppendLine("[FAIL] ⑤ 클론 주입 실패"); return 1; }
        st.enabled = true; st.deathDisplaySeconds = 2f; st.holdWorldWhileReviving = true; st.autoReviveWhenNoListener = true; st.autoReviveTimeoutSeconds = 0f;
        st.reviveInvincibleSeconds = 1.5f; st.reviveHealRate = 1f; st.reviveCompanions = true;
        DeathFlow.ResetDiagnostics(); Survival.ResetDiagnostics();
        int died = 0, requested = 0, revived = 0, revivedExternal = 0, revivedAuto = 0, overrideCalls = 0; bool lastHeld = true; float lastInv = -1f;
        CombatHandler<DeathEvent> onDied = (in DeathEvent e) => { died++; };
        CombatHandler<ReviveRequestEvent> onReq = (in ReviveRequestEvent e) => { requested++; lastHeld = e.worldHeld; };
        CombatHandler<RevivedEvent> onRev = (in RevivedEvent e) => { revived++; if (e.external) revivedExternal++; if (e.auto) revivedAuto++; lastInv = e.invincibleSeconds; };
        DeathFlow.Died.Add(onDied); DeathFlow.ReviveRequested.Add(onReq); DeathFlow.Revived.Add(onRev);
        DeathFlow.ReviveOverride = (pc, rate) => { overrideCalls++; SetDead(pc, false); SetHp(pc, pc.Get_MaxHP() * rate); };
        var pc = MakePC("pc", 1000, 0); var enemyPc = MakePC("enemyPc", 1000, 0, true);
        float ts = Time.timeScale;
        int fails = 0;
        try
        {
            // a) 정상 사이클: 사망 → 2 s → 요청 → Revive() → 부활 + 무적 1.5 s
            Survival.Tick(50f); DeathFlow.Tick(100f); SetDead(pc, true);
            DeathFlow.OnPCDied(pc);
            bool a1 = DeathFlow.State == DeathState.Dying && died == 1 && DeathFlow.DeathCount == 1 && DeathFlow.Current == pc;
            DeathFlow.Tick(101f); bool a2 = DeathFlow.State == DeathState.Dying && requested == 0 && Math.Abs(DeathFlow.DisplayRemaining - 1f) < 1e-4f;
            DeathFlow.Tick(101.99f); bool a3 = DeathFlow.State == DeathState.Dying && requested == 0;
            DeathFlow.Tick(102f); bool a4 = DeathFlow.State == DeathState.AwaitingRevive && requested == 1 && !lastHeld && !DeathFlow.WorldHeld && IsDead(pc);
            bool a5 = DeathFlow.Revive();
            bool a6 = DeathFlow.State == DeathState.None && revived == 1 && revivedExternal == 0 && revivedAuto == 0 && overrideCalls == 1 && !IsDead(pc) && pc.Get_HP() == 1000d && Math.Abs(lastInv - 1.5f) < 1e-4f;
            bool a7 = Survival.IsReviveInvincible(pc) && Math.Abs(Survival.ReviveInvincibleRemaining - 1.5f) < 1e-4f;
            Survival.Tick(51.5f); bool a8 = !Survival.IsReviveInvincible(pc);
            bool a = a1 && a2 && a3 && a4 && a5 && a6 && a7 && a8;
            sb.AppendLine(P(a) + " ⑤a 사이클: Dying " + a1 + " · t+1 Dying(remain " + (a2 ? "1.00" : DeathFlow.DisplayRemaining.ToString("F2")) + ") · t+1.99 " + a3 + " · t+2 Awaiting+ReviveRequested(held=" + lastHeld + " · 에디트 모드 기대 false) " + a4
                + " · Revive()=" + a5 + " → None/Revived/무적 1.5 " + a6 + " · 창 " + a7 + " → 1.5 s 뒤 해제 " + a8 + " · LastDeathToRequest=" + DeathFlow.LastDeathToRequest.ToString("F2"));
            if (!a) fails++;

            // b) 구독자 0 → 자동 부활
            DeathFlow.ReviveRequested.Remove(onReq);
            SetDead(pc, true); DeathFlow.Tick(200f); DeathFlow.OnPCDied(pc); DeathFlow.Tick(202f);
            bool b = DeathFlow.State == DeathState.None && revived == 2 && revivedAuto == 1 && !IsDead(pc) && DeathFlow.AutoReviveCount == 1;
            sb.AppendLine(P(b) + " ⑤b 구독자 0 자동 부활: state=" + DeathFlow.State + " revived=" + revived + " auto=" + revivedAuto);
            if (!b) fails++;
            DeathFlow.ReviveRequested.Add(onReq);

            // c) 외부(원본 After_Die)가 먼저 살림 → external
            SetDead(pc, true); DeathFlow.Tick(300f); DeathFlow.OnPCDied(pc); DeathFlow.Tick(302f);
            bool c1 = DeathFlow.State == DeathState.AwaitingRevive && requested == 2;
            SetDead(pc, false); int ov = overrideCalls; DeathFlow.Tick(302.1f);
            bool c = c1 && DeathFlow.State == DeathState.None && revived == 3 && revivedExternal == 1 && overrideCalls == ov && Survival.IsReviveInvincible(pc);
            sb.AppendLine(P(c) + " ⑤c 외부 부활 감지: Awaiting " + c1 + " → external=" + revivedExternal + " override 미호출 " + (overrideCalls == ov) + " 무적 " + Survival.IsReviveInvincible(pc));
            if (!c) fails++;

            // d) 연출 중 조기 응답 → 연출 끝에 부활
            SetDead(pc, true); DeathFlow.Tick(400f); DeathFlow.OnPCDied(pc); DeathFlow.Tick(400.5f);
            bool d1 = DeathFlow.Revive() && DeathFlow.State == DeathState.Dying && IsDead(pc);
            DeathFlow.Tick(402f);
            bool d = d1 && DeathFlow.State == DeathState.None && revived == 4 && !IsDead(pc) && requested == 3;
            sb.AppendLine(P(d) + " ⑤d 조기 응답: Dying 유지 " + d1 + " → 2 s 뒤 부활 " + (DeathFlow.State == DeathState.None) + " revived=" + revived);
            if (!d) fails++;

            // e) 타임아웃 자동 부활
            st.autoReviveTimeoutSeconds = 3f;
            SetDead(pc, true); DeathFlow.Tick(500f); DeathFlow.OnPCDied(pc); DeathFlow.Tick(502f);
            bool e1 = DeathFlow.State == DeathState.AwaitingRevive;
            DeathFlow.Tick(504.9f); bool e2 = DeathFlow.State == DeathState.AwaitingRevive;
            DeathFlow.Tick(505f); bool e3 = DeathFlow.State == DeathState.None && revived == 5 && revivedAuto == 2;
            st.autoReviveTimeoutSeconds = 0f;
            bool e = e1 && e2 && e3;
            sb.AppendLine(P(e) + " ⑤e 타임아웃 3 s: +2.9 대기 " + e2 + " · +3.0 자동 부활 " + e3 + " · LastRequestToRevive=" + DeathFlow.LastRequestToRevive.ToString("F2"));
            if (!e) fails++;

            // f) Abort · 중복 사망 · 적 PC
            SetDead(pc, true); DeathFlow.Tick(600f); DeathFlow.OnPCDied(pc); int dc = DeathFlow.DeathCount;
            DeathFlow.OnPCDied(pc); bool f1 = DeathFlow.DeathCount == dc;
            DeathFlow.Abort("probe"); bool f2 = DeathFlow.State == DeathState.None && DeathFlow.AbortCount == 1 && revived == 5 && IsDead(pc);
            SetDead(pc, false);
            SetDead(enemyPc, true); DeathFlow.OnPCDied(enemyPc); bool f3 = DeathFlow.State == DeathState.None && DeathFlow.DeathCount == dc; SetDead(enemyPc, false);
            bool f4 = Time.timeScale == ts;
            bool f = f1 && f2 && f3 && f4;
            sb.AppendLine(P(f) + " ⑤f 중복 사망 무시 " + f1 + " · Abort " + f2 + " · 적 PC 무시 " + f3 + " · timeScale 무변경 " + f4 + " (" + Time.timeScale + ")");
            if (!f) fails++;

            // g) Revive() with nothing pending → false
            bool g = !DeathFlow.Revive();
            sb.AppendLine(P(g) + " ⑤g 대기 없는 Revive()=false " + g);
            if (!g) fails++;
        }
        finally
        {
            DeathFlow.Died.Remove(onDied); DeathFlow.ReviveRequested.Remove(onReq); DeathFlow.Revived.Remove(onRev);
            DeathFlow.ReviveOverride = null; DeathFlow.ResetDiagnostics(); Survival.ResetDiagnostics();
            Kill(pc, enemyPc);
        }
        return fails;
    }

    // ───────────────────────────────────────── ⑥ 이벤트 GC
    static int EventGc(StringBuilder sb)
    {
        var st = UseClone(); if (st == null) { sb.AppendLine("[FAIL] ⑥ 클론 주입 실패"); return 1; }
        st.enabled = true; st.verboseLog = false;
        int n = 0;
        CombatHandler<PotionEvent> h = (in PotionEvent e) => { n++; };
        PotionUse.Changed.Add(h);
        try
        {
            for (int i = 0; i < 10; i++) PotionUse.ResetRun("");
            GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect();
            int g0 = GC.CollectionCount(0); long a0 = Alloc(), p0 = Mono();
            for (int i = 0; i < 1000000; i++) PotionUse.ResetRun("");
            long a1 = Alloc(), p1 = Mono(); int g1 = GC.CollectionCount(0);
            bool ok = a1 - a0 == 0L && p1 - p0 == 0L && g1 == g0 && n == 1000010;
            sb.AppendLine(P(ok) + " ⑥ PotionUse.Changed 디스패치×1,000,000 = 힙 " + (a1 - a0) + " B / mono " + (p1 - p0) + " B / 수집 " + (g1 - g0) + "회 (기대 0) handler=" + n);
            return ok ? 0 : 1;
        }
        finally { PotionUse.Changed.Remove(h); PotionUse.ResetDiagnostics(); }
    }

    // ───────────────────────────────────────── ⑦ 정리
    static int Cleanup(StringBuilder sb, float ts0)
    {
        RestoreAsset();
        if (s_clone != null) { UnityEngine.Object.DestroyImmediate(s_clone); s_clone = null; }
        Survival.ResetDiagnostics(); PotionUse.ResetDiagnostics(); DeathFlow.ResetDiagnostics();
        var st = WLSurvivalSettings.Instance;
        bool assetBack = st != null && !st.enabled && !WLSurvivalSettings.Enabled;
        bool flag = WL.Settings.WLGameplaySettings.PlayerInvincible;
        int leftovers = 0;
        foreach (var go in UnityEngine.Object.FindObjectsByType<GameObject>(FindObjectsInactive.Include, FindObjectsSortMode.None))
            if (go != null && go.name.StartsWith("__WL813i_")) { leftovers++; UnityEngine.Object.DestroyImmediate(go); }
        bool dirty = false; string scene = "?";
#if UNITY_EDITOR
        var sc = UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene(); dirty = sc.isDirty; scene = sc.name;
#endif
        bool ok = assetBack && flag && leftovers == 0 && Time.timeScale == ts0 && !SurvivalRunner.Exists && MyValue.MyPC == null;
        sb.AppendLine(P(ok) + " ⑦ 정리: 디스크 에셋 enabled=false 복귀 " + assetBack + " · playerInvincible=" + flag + " · 잔존 오브젝트 " + leftovers
            + " · timeScale " + Time.timeScale + "(시작 " + ts0 + ") · 러너 생성 0 " + !SurvivalRunner.Exists + " · MyPC=null " + (MyValue.MyPC == null) + " · 씬 '" + scene + "' dirty=" + dirty);
        return ok ? 0 : 1;
    }
}