// ─────────────────────────────────────────────────────────────────────────────
//  LootToast.cs — 전리품 획득 토스트 (WL-813g §1-3 · #813)
//
//  기준서 v1 §B 요소 4 「토스트 1.2 s · 동시 3줄 · 등급 색(보유 팔레트 그대로)」 · §C 요소 4 「토스트 없음 → 813g(U)」.
//
//  ■ 입력 경로 (지금 / 나중)
//    · 지금  = `CombatEvents.Killed`(811b 코어) 로 "뭔가 죽었다"를 알고, 그 뒤 `DropItemInfo.m_StageDropData`
//              획득 집계의 **델타**를 폴링해 실제로 먹은 아이템만 줄로 띄운다(원본 훅 0 · Gameplay 코드 0).
//              집계는 `DropItem.cs:125 Add_Item` 이 채우는 값이라 "떨어진 것"이 아니라 "**주운 것**"이다.
//    · 나중  = 813f 가 드랍/획득 이벤트를 내면 `Push(itemId, count)` 로 바로 밀어 넣고 폴링을 걷어낸다(후속).
//
//  ■ 등급 색 = `MyValue.Get_GradeColor`(원본 팔레트) 를 그대로 쓴다 — 기준서 §B 요소 4 「새 색 만들 이유 없음」.
//    설정 에셋의 lootToastGradeColors 를 채우면 그 값이 우선한다(SO 이관 대비).
//
//  ■ Safe Area (813c 규칙) — 부모(`IngameUIs/WL_HUD`)가 이미 SafeAreaFitter 아래다. 여기서는 부모 기준 우측 정렬만 한다.
//
//  ■ 롤백(C8) — 설정이 없거나 textEnabled/lootToastEnabled = false 면 구독·폴링 0 · 표시 0.
//
//  🔴 어셈블리 주의: Assets/WL/UI/ 에 .asmdef 를 만들지 말 것(Assembly-CSharp 단일).
// ─────────────────────────────────────────────────────────────────────────────

using System.Collections.Generic;
using System.Text;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using WL.Combat.Core;

namespace WL.UI
{
    [DisallowMultipleComponent]
    [RequireComponent(typeof(RectTransform))]
    public class LootToast : MonoBehaviour
    {
        [Header("구성 요소 (BuildIfNeeded 가 만든다)")]
        [SerializeField] private RectTransform lineRoot;
        [SerializeField] private TMP_FontAsset font;

        private class Line
        {
            public RectTransform rt;
            public TextMeshProUGUI label;
            public CanvasGroup group;
            public Image panel;                 // WL-813y — 밝은 배경 대비용 반투명 패널
            public int itemId, count;
            public float life, lifeMax, elapsed;
            public bool used;
        }

        private readonly List<Line> _lines = new List<Line>();
        private readonly Dictionary<int, int> _seen = new Dictionary<int, int>();   // itemId → 마지막으로 본 누적 수량
        private RectTransform _rt;
        private bool _subscribed;
        private float _nextPoll;
        private bool _armed;          // Killed 를 한 번이라도 본 뒤부터 폴링한다(로비에서 헛돌지 않게)

        // ── WL-813z(D-7) Safe Area 클램프 실값(ApplyLayout 이 계산 · Update 슬라이드가 읽는다)
        private float _widthPx, _rightPx, _padPx, _slideMaxPx;
        /// <summary>WL-813z — 마지막 클램프 실측(프로브·Dump 용).</summary>
        public string LastClamp { get; private set; } = "";

        // ── 진단(프로브가 읽는다 · 실측만)
        public int KilledSeen { get; private set; }
        public int PushCount { get; private set; }
        public int MergeCount { get; private set; }
        public int DropCount { get; private set; }     // 줄 상한 초과로 밀려난 수
        public bool Subscribed { get { return _subscribed; } }
        /// <summary>마지막으로 적용한 아웃라인/그림자 실측 문자열(WL-813y).</summary>
        public string LastEdge { get; private set; } = "";
        public int VisibleLines
        {
            get { int n = 0; for (int i = 0; i < _lines.Count; i++) if (_lines[i].used) n++; return n; }
        }

        private void OnEnable() { Initialize(); }
        private void OnDisable() { Subscribe(false); }

        /// <summary>OnEnable 본체 분리(813c 교훈) — 에디트 모드도 같은 경로.</summary>
        public string Initialize()
        {
            _rt = GetComponent<RectTransform>();
            BuildIfNeeded();
            string layout = ApplyLayout();
            HideAll();
            var s = WLCombatTextSettings.Instance;
            bool on = WLCombatTextSettings.Enabled && s != null && s.lootToastEnabled;
            Subscribe(on);
            return (on ? "구독 ON · " : "설정 off — 구독 0 · ") + layout;
        }

        public void Subscribe(bool on)
        {
            if (on == _subscribed) return;
            if (on) CombatEvents.Killed.Add(OnKilled);
            else CombatEvents.Killed.Remove(OnKilled);
            _subscribed = on;
        }

        /// <summary>설정의 줄 수만큼 라벨을 만든다(줄 수를 바꾸면 다시 만든다).</summary>
        public bool BuildIfNeeded()
        {
            if (_rt == null) _rt = GetComponent<RectTransform>();
            var s = WLCombatTextSettings.Instance;
            int want = s != null ? Mathf.Max(1, s.lootToastLines) : 3;
            bool made = false;
            if (lineRoot == null) { lineRoot = WLTextFxUtil.NewChild(_rt, "Lines"); made = true; }

            while (_lines.Count < want)
            {
                int idx = _lines.Count;
                var lrt = WLTextFxUtil.NewChild(lineRoot, "Line" + idx);
                // 패널을 먼저 만든다 — uGUI 는 형제 순서가 곧 그리는 순서라 라벨이 위로 온다(813tj 교훈).
                var prt = WLTextFxUtil.NewChild(lrt, "Panel");
                var panel = prt.GetComponent<Image>();
                if (panel == null) panel = prt.gameObject.AddComponent<Image>();
                panel.raycastTarget = false;
                var label = WLTextFxUtil.NewText(lrt, "Label", font, TextAlignmentOptions.Right);
                var cg = lrt.GetComponent<CanvasGroup>();
                if (cg == null) cg = lrt.gameObject.AddComponent<CanvasGroup>();
                cg.interactable = false; cg.blocksRaycasts = false; cg.alpha = 0f;
                _lines.Add(new Line { rt = lrt, label = label, group = cg, panel = panel });
                made = true;
            }
            for (int i = want; i < _lines.Count; i++)
                if (_lines[i].rt != null) _lines[i].group.alpha = 0f;   // 남는 줄은 숨기기만(파괴하지 않는다)
            return made;
        }

        /// <summary>우측 정렬 · 줄 간격 · 글자 크기 (px → 유닛 환산은 캔버스에서 · 상수 0).</summary>
        public string ApplyLayout()
        {
            var s = WLCombatTextSettings.Instance;
            if (s == null) return "WLCombatTextSettings 없음 — 배치 건너뜀";
            if (_rt == null) _rt = GetComponent<RectTransform>();
            if (lineRoot == null) return "구성 요소 없음 — BuildIfNeeded 먼저";

            float u = WLTextFxUtil.UnitsPerPx(this, s);
            WLTextFxUtil.Stretch(_rt);

            // ── WL-813z(D-7) — 폭·오른쪽 여백·슬라이드 시작 x 를 Safe Area 안으로 클램프.
            //    부모(IngameUIs/WL_HUD)는 SafeAreaFitter 아래이므로 이 RectTransform 의 rect 가 곧 Safe Area 다.
            //    중심 오프셋(lootToastCenterOffsetPx)은 발주서 지시대로 **그대로 둔다**.
            _widthPx = s.lootToastWidthPx;
            _rightPx = s.lootToastRightMarginPx;
            _padPx = 0f;
            _slideMaxPx = s.lootToastSlideInPx;
            float parentPx = u > 0.0001f ? _rt.rect.width / u : 0f;
            if (s.lootToastClampToSafeArea)
            {
                _padPx = Mathf.Max(0f, s.lootToastSafePadPx) + (s.lootToastPanelEnabled ? Mathf.Max(0f, s.lootToastPanelPadXPx) : 0f);
                _rightPx = Mathf.Max(_padPx, _rightPx);
                if (s.lootToastMaxWidthPx > 0f) _widthPx = Mathf.Min(_widthPx, s.lootToastMaxWidthPx);
                if (parentPx > 1f) _widthPx = Mathf.Min(_widthPx, parentPx - _rightPx - _padPx);
                _widthPx = Mathf.Max(1f, _widthPx);
                _slideMaxPx = Mathf.Clamp(_rightPx - _padPx, 0f, s.lootToastSlideInPx);   // 등장 중에도 오른쪽 밖으로 못 나간다
            }
            LastClamp = "부모=" + parentPx.ToString("F1") + "px · 폭 " + s.lootToastWidthPx.ToString("F0") + "→" + _widthPx.ToString("F1") +
                        "px(상한 " + s.lootToastMaxWidthPx.ToString("F0") + ") · 우여백 " + s.lootToastRightMarginPx.ToString("F0") + "→" + _rightPx.ToString("F1") +
                        "px · pad=" + _padPx.ToString("F1") + "px · 슬라이드 " + s.lootToastSlideInPx.ToString("F0") + "→" + _slideMaxPx.ToString("F1") +
                        "px · 우측 최대 침범 " + Mathf.Max(0f, _slideMaxPx + _padPx - _rightPx).ToString("F1") + "px · clamp=" + s.lootToastClampToSafeArea;

            lineRoot.anchorMin = lineRoot.anchorMax = new Vector2(1f, 0.5f);   // 우측 · 세로 중앙 기준
            lineRoot.pivot = new Vector2(1f, 0.5f);
            lineRoot.sizeDelta = new Vector2(_widthPx * u, s.lootToastLineHeightPx * s.lootToastLines * u);
            lineRoot.anchoredPosition = new Vector2(-_rightPx * u, s.lootToastCenterOffsetPx * u);

            var sb = new StringBuilder();
            sb.Append("lines=").Append(_lines.Count).Append(" root pos=").Append(lineRoot.anchoredPosition)
              .Append(" size=").Append(lineRoot.sizeDelta).Append(" unitsPerPx=").Append(u.ToString("F4"))
              .Append(" · ").Append(LastClamp);
            for (int i = 0; i < _lines.Count; i++)
            {
                var l = _lines[i];
                l.rt.anchorMin = l.rt.anchorMax = new Vector2(1f, 1f);
                l.rt.pivot = new Vector2(1f, 1f);
                l.rt.sizeDelta = new Vector2(_widthPx * u, s.lootToastLineHeightPx * u);
                l.rt.anchoredPosition = new Vector2(0f, -s.lootToastLineHeightPx * i * u);
                WLTextFxUtil.Stretch(l.label.rectTransform);
                l.label.fontSize = s.lootToastFontPx * u;
                l.label.alignment = TextAlignmentOptions.MidlineRight;

                // WL-813z(D-7) — 긴 아이템 이름은 줄바꿈 대신 말줄임(…)으로 자른다(폭 밖으로 밀려나지 않게).
                if (s.lootToastEllipsis)
                {
                    if (l.label.textWrappingMode != TextWrappingModes.NoWrap) l.label.textWrappingMode = TextWrappingModes.NoWrap;
                    if (l.label.overflowMode != TextOverflowModes.Ellipsis) l.label.overflowMode = TextOverflowModes.Ellipsis;
                }

                // WL-813y — 줄 뒤 패널(대비) + 글자 아웃라인. 값은 전부 SO.
                if (l.panel != null)
                {
                    bool on = s.lootToastPanelEnabled;
                    if (l.panel.enabled != on) l.panel.enabled = on;
                    l.panel.color = s.lootToastPanelColor;
                    var prt = l.panel.rectTransform;
                    prt.anchorMin = Vector2.zero; prt.anchorMax = Vector2.one; prt.pivot = new Vector2(0.5f, 0.5f);
                    prt.offsetMin = new Vector2(-s.lootToastPanelPadXPx * u, -s.lootToastPanelPadYPx * u);
                    prt.offsetMax = new Vector2(s.lootToastPanelPadXPx * u, s.lootToastPanelPadYPx * u);
                }
                LastEdge = WLTextFxUtil.ApplyEdge(l.label, s.Edge(s.lootToastEdge));
                sb.Append(" · [").Append(i).Append("] pos=").Append(l.rt.anchoredPosition);
            }
            return sb.ToString();
        }

        // ───────────────────────────────────────────── 입력

        private void OnKilled(in KilledEvent e)
        {
            KilledSeen++;
            _armed = true;      // 처치가 있어야 드랍이 있다 — 그 뒤부터만 획득 집계를 본다
        }

        /// <summary>813f(후속) · 프로브 공용 입력 — 아이템 1건 획득을 줄로 띄운다.</summary>
        public string Push(int itemId, int count)
        {
            int r = PushCore(itemId, count);
            switch (r)
            {
                case kOff: return "설정 off — 표시 0";
                case kGold: return "골드 제외(설정) — 표시 0";
                case kGrade: return "등급 하한 미만 — 표시 0";
                case kMerged: return "merge item=" + itemId + " count=" +
                                     (_lastPushLine >= 0 && _lastPushLine < _lines.Count ? _lines[_lastPushLine].count : count) +
                                     " line=" + _lastPushLine;
                case kQueued: return "queue item=" + itemId + " count=" + count + " 대기=" + _qCount + "(오래된 줄 페이드)";
                case kQueueDropped: return "queue full item=" + itemId + " — 버림(대기 " + _qCount + ")";
                default: return "push item=" + itemId + " count=" + count + " line=" + _lastPushLine;
            }
        }

        // ── WL-813c2 (Q6 D-31) — 큐 · 병합 · 넘침 페이드 ────────────────────────
        //   실측: 화면 동시 줄 수는 813g 때부터 `lootToastLines`(3)로 막혀 있었다. Q6 의 「창 안 6줄」은
        //   프로브가 **표시 시간 창 안의 Picked 이벤트 수**를 센 값이다(`WL813_ScoreProbe.cs:437~443`).
        //   실물 결함은 넘칠 때 오래된 줄이 **페이드 없이 즉시 다른 내용으로 교체**돼 깜빡이는 것이다.
        //   → ① 같은 아이템은 보이는 동안 계속 수량 병합("금화 ×8") ② 넘치면 오래된 줄을 즉시 페이드시키고
        //      새 줄은 **고정 크기 링 큐**에서 자리를 기다린다(동시 줄 수 상한 유지 · 할당 0).
        //   C8 롤백 = `lootToastOverflowFadeSec = 0` → 813g 의 즉시 한 칸 당김 그대로.

        private const int kOff = 0, kGold = 1, kGrade = 2, kMerged = 3, kShown = 4, kQueued = 5, kQueueDropped = 6;
        private int _lastPushLine = -1;

        private struct Pending { public int itemId, count; }
        private Pending[] _queue = new Pending[0];
        private int _qHead, _qCount;

        /// <summary>지금 자리를 기다리는 건수(진단).</summary>
        public int QueuedCount { get { return _qCount; } }
        /// <summary>큐가 꽉 차 버린 건수(진단).</summary>
        public int QueueDropCount { get; private set; }
        /// <summary>넘침으로 즉시 페이드시킨 줄 수(진단).</summary>
        public int OverflowFadeCount { get; private set; }

        /// <summary>문자열을 만들지 않는 입력 본체(GC 0). 돌려주는 값은 위 k* 코드.</summary>
        private int PushCore(int itemId, int count)
        {
            _lastPushLine = -1;
            var s = WLCombatTextSettings.Instance;
            if (s == null || !WLCombatTextSettings.Enabled || !s.lootToastEnabled) return kOff;
            if (!s.lootToastIncludeGold && itemId == GoldItemId) return kGold;

            int grade; string name;
            ResolveItem(itemId, out grade, out name);
            if (grade < s.lootToastMinGrade) return kGrade;

            BuildIfNeeded();
            int n = LineCap(s);

            // ① 같은 아이템 병합 — 보이는 동안이면 창과 무관하게(설정) 수량만 올린다.
            for (int i = 0; i < n; i++)
            {
                var l = _lines[i];
                if (!l.used || l.itemId != itemId) continue;
                if (!s.lootToastMergeWhileVisible && l.elapsed > s.lootToastMergeSeconds) continue;
                l.count += count;
                l.life = l.lifeMax; l.elapsed = 0f; l.group.alpha = 1f;
                Render(l, name, grade, s);
                MergeCount++; _lastPushLine = i;
                return kMerged;
            }

            // ② 빈 줄이 있으면 바로 띄운다(지연 0).
            int slot = FreeSlot(s);
            if (slot >= 0) { Occupy(slot, itemId, count, name, grade, s); return kShown; }

            // ③ 넘침 — 오래된 줄을 즉시 페이드시키고 새 줄은 큐에서 기다린다.
            if (s.lootToastOverflowFadeSec > 0f)
            {
                FadeOldest(s);
                return Enqueue(s, itemId, count) ? kQueued : kQueueDropped;
            }

            // ④ C8 롤백 경로(페이드 0) — 813g 그대로 한 칸씩 당기고 마지막 자리를 쓴다.
            slot = ShiftUp(s);
            Occupy(slot, itemId, count, name, grade, s);
            return kShown;
        }

        /// <summary>표가 아직 안 올라온 시점(에디트 모드·로딩 중)에도 죽지 않게 감싼다 — 없으면 ID·등급 1.</summary>
        private static void ResolveItem(int itemId, out int grade, out string name)
        {
            grade = 1; name = null;
            try
            {
                var data = table_itemlist.Ins != null ? table_itemlist.Ins.Get_Data(itemId) : null;
                if (data != null)
                {
                    grade = Mathf.Max(1, data.n_ItemGrade);
                    var n = data.Get_Name();
                    if (!string.IsNullOrEmpty(n)) name = n;
                }
            }
            catch { /* 표 미로드 · ID 없음 — 기본값으로 표시 */ }
            if (name == null) name = itemId.ToString();
        }

        /// <summary>지금 쓸 수 있는 줄 수 = min(만들어 둔 줄, 설정 상한).</summary>
        private int LineCap(WLCombatTextSettings s)
        {
            return Mathf.Min(_lines.Count, Mathf.Max(1, s.lootToastLines));
        }

        private int FreeSlot(WLCombatTextSettings s)
        {
            int n = LineCap(s);
            for (int i = 0; i < n; i++) if (!_lines[i].used) return i;
            return -1;
        }

        private void Occupy(int slot, int itemId, int count, string name, int grade, WLCombatTextSettings s)
        {
            var line = _lines[slot];
            line.used = true; line.itemId = itemId; line.count = count;
            line.lifeMax = line.life = Mathf.Max(0.01f, s.lootToastSeconds);
            line.elapsed = 0f;
            line.group.alpha = 1f;
            Render(line, name, grade, s);
            PushCount++; _lastPushLine = slot;
        }

        /// <summary>남은 수명이 가장 짧은 줄(= 가장 오래된 줄)을 페이드 시간으로 줄인다 — 「넘치면 오래된 줄 즉시 페이드」.</summary>
        private void FadeOldest(WLCombatTextSettings s)
        {
            int n = LineCap(s), pick = -1; float least = float.MaxValue;
            for (int i = 0; i < n; i++)
            {
                var l = _lines[i];
                if (!l.used) continue;
                if (l.life < least) { least = l.life; pick = i; }
            }
            if (pick < 0) return;
            float f = Mathf.Max(0.01f, s.lootToastOverflowFadeSec);
            if (_lines[pick].life <= f) return;         // 이미 그만큼만 남았으면 건드리지 않는다
            _lines[pick].life = f;
            _lines[pick].lifeMax = f;                   // Passed = 1 − life/lifeMax → 곧바로 페이드 구간
            OverflowFadeCount++; DropCount++;
        }

        private void EnsureQueue(WLCombatTextSettings s)
        {
            int want = Mathf.Max(0, s.lootToastQueueMax);
            if (_queue.Length == want) return;
            _queue = new Pending[want];                 // 설정을 바꿀 때만 1회 — 폴링·프레임 경로에서는 할당 0
            _qHead = 0; _qCount = 0;
        }

        private bool Enqueue(WLCombatTextSettings s, int itemId, int count)
        {
            EnsureQueue(s);
            if (_queue.Length == 0) return false;

            for (int k = 0; k < _qCount; k++)           // 큐 안에서도 같은 아이템은 수량만 더한다
            {
                int idx = (_qHead + k) % _queue.Length;
                if (_queue[idx].itemId != itemId) continue;
                _queue[idx].count += count; MergeCount++;
                return true;
            }
            if (_qCount >= _queue.Length)               // 꽉 차면 가장 오래 기다린 항목을 버린다
            {
                _qHead = (_qHead + 1) % _queue.Length; _qCount--;
                QueueDropCount++;
            }
            int tail = (_qHead + _qCount) % _queue.Length;
            _queue[tail].itemId = itemId; _queue[tail].count = count;
            _qCount++;
            return true;
        }

        /// <summary>자리가 나면 큐에서 꺼내 띄운다(매 프레임 · 문자열 0).</summary>
        private void FlushQueue(WLCombatTextSettings s)
        {
            if (_qCount <= 0 || _queue.Length == 0) return;
            int guard = _queue.Length;
            while (_qCount > 0 && guard-- > 0)
            {
                int slot = FreeSlot(s);
                if (slot < 0) return;
                var p = _queue[_qHead];
                _qHead = (_qHead + 1) % _queue.Length; _qCount--;
                int grade; string name;
                ResolveItem(p.itemId, out grade, out name);
                Occupy(slot, p.itemId, p.count, name, grade, s);
            }
        }

        /// <summary>프로브 전용 — 자리가 난 만큼 큐를 밀어 넣고 띄운 건수를 돌려준다(런타임은 Update 가 매 프레임 부른다).</summary>
        public int FlushQueueNow()
        {
            var s = WLCombatTextSettings.Instance;
            if (s == null) return 0;
            int before = _qCount;
            FlushQueue(s);
            return before - _qCount;
        }

        /// <summary>C8 롤백 경로 — 0번을 버리고 한 칸씩 올린다(내용만 옮기고 RectTransform 은 그대로).</summary>
        private int ShiftUp(WLCombatTextSettings s)
        {
            int n = LineCap(s);
            DropCount++;
            for (int i = 0; i < n - 1; i++)
            {
                var a = _lines[i]; var b = _lines[i + 1];
                a.itemId = b.itemId; a.count = b.count; a.life = b.life; a.lifeMax = b.lifeMax; a.elapsed = b.elapsed;
                a.used = b.used; a.label.text = b.label.text; a.label.color = b.label.color; a.group.alpha = b.group.alpha;
            }
            _lines[n - 1].used = false;
            return n - 1;
        }

        private void Render(Line l, string name, int grade, WLCombatTextSettings s)
        {
            string colored = s.GradeColorTagBright(grade) + name;   // WL-813y — 등급 1 회색이 모래 배경에서 사라진다(Q3 D-6 ②)
            l.label.text = l.count > 1
                ? DSUtil.Format(s.lootToastFormat, colored, l.count)
                : DSUtil.Format(s.lootToastFormatSingle, colored);
            l.label.color = Color.white;   // 등급색은 리치텍스트 태그가 담당한다(원본 팔레트 그대로)
        }

        public void HideAll()
        {
            for (int i = 0; i < _lines.Count; i++)
            {
                _lines[i].used = false;
                _lines[i].life = 0f;
                if (_lines[i].group != null) _lines[i].group.alpha = 0f;
                if (_lines[i].label != null) _lines[i].label.text = "";
            }
            _qHead = 0; _qCount = 0;                    // WL-813c2 — 대기 큐도 비운다
        }

        // ───────────────────────────────────────────── 폴링 · 수명

        /// <summary>골드 아이템 ID — 원본 DropItemInfo 의 코인 분기 키(`DropItemInfo.cs:12` dic_addrPath[2]).</summary>
        public const int GoldItemId = 2;

        private void Update()
        {
            var s = WLCombatTextSettings.Instance;
            if (s == null) return;

            // ── 획득 집계 폴링(813f 이벤트가 오면 걷어낸다)
            //    🔴 WL-813c2 — 게임 경로는 **문자열을 만들지 않는 갈래**로 부른다(기존에는 폴링마다
            //       `new StringBuilder()` + 진단 문자열이 초당 10회 났다 = GC). 진단용 문자열 갈래는 프로브 전용.
            if (_armed && Application.isPlaying && s.lootToastPollHz > 0f && Time.unscaledTime >= _nextPoll)
            {
                _nextPoll = Time.unscaledTime + 1f / Mathf.Max(0.1f, s.lootToastPollHz);
                PollStageDropCore(null);
            }

            // ── WL-813c2(D-31) — 넘쳐서 기다리던 줄을 자리가 나는 대로 띄운다
            FlushQueue(s);

            // ── 줄 수명
            float dt = Time.unscaledDeltaTime;
            float u = WLTextFxUtil.UnitsPerPx(this, s);
            for (int i = 0; i < _lines.Count; i++)
            {
                var l = _lines[i];
                if (!l.used) continue;
                l.life -= dt; l.elapsed += dt;
                float passed = WLTextFxUtil.Passed(l.life, l.lifeMax);
                l.group.alpha = WLTextFxUtil.FadeAlpha(passed, s.lootToastFadeStartRatio);
                if (s.lootToastSlideInPx > 0f && s.lootToastSlideSeconds > 0f)
                {
                    float k = Mathf.Clamp01(l.elapsed / s.lootToastSlideSeconds);
                    // WL-813z(D-7) — 등장 x 상한 = Safe Area 를 넘지 않는 값(ApplyLayout 계산 · 클램프 off 면 원래 값).
                    float startPx = s.lootToastClampToSafeArea ? _slideMaxPx : s.lootToastSlideInPx;
                    float x = Mathf.Lerp(startPx, 0f, k) * u;
                    l.rt.anchoredPosition = new Vector2(x, -s.lootToastLineHeightPx * i * u);
                }
                if (l.life <= 0f) { l.used = false; l.group.alpha = 0f; l.label.text = ""; }
            }
        }

        /// <summary>StageDropData 의 아이템 누적 수량 델타 = 이번에 주운 것(진단 문자열 갈래 · 프로브 전용).</summary>
        public string PollStageDrop() { return PollStageDropCore(new StringBuilder()); }

        /// <summary>폴링 본체. <paramref name="sb"/> 가 null 이면 문자열을 하나도 만들지 않는다(게임 경로 · GC 0).</summary>
        private string PollStageDropCore(StringBuilder sb)
        {
            if (!DropItemInfo.isIns || DropItemInfo.Ins == null) return "DropItemInfo 없음";
            var data = DropItemInfo.Ins.m_StageDropData;
            if (data == null) return "StageDropData 없음";
            var dic = data.Get_Item();
            if (dic == null) return "집계 없음";

            foreach (var kv in dic)                     // Dictionary 열거자는 구조체 = 할당 0
            {
                int id = kv.Key;
                int now = kv.Value;
                int last;
                if (!_seen.TryGetValue(id, out last)) last = 0;
                if (now > last)
                {
                    DropCountedItems++;
                    if (sb != null) sb.Append(Push(id, now - last)).Append(" | ");
                    else PushCore(id, now - last);
                }
                _seen[id] = now;
            }
            return sb != null && sb.Length > 0 ? sb.ToString() : "델타 0";
        }

        /// <summary>진단 — 폴링으로 잡아낸 획득 건수.</summary>
        public int DropCountedItems { get; private set; }

        /// <summary>스테이지가 바뀌면 집계 기준을 초기화한다(StageDropData.Init 과 짝).</summary>
        public void ResetPollBaseline()
        {
            _seen.Clear(); _armed = false; DropCountedItems = 0;
            _qHead = 0; _qCount = 0; QueueDropCount = 0; OverflowFadeCount = 0;   // WL-813c2
        }

        // ───────────────────────────────────────────── 프로브(에디트 모드 · Play 0)

        /// <summary>합성 처치 이벤트 — 811b 코어의 실제 Dispatch 경로(구독 배선까지 검증).</summary>
        public static string RaiseFakeKilled()
        {
            var e = new KilledEvent
            {
                victim = null, killer = null, subRole = eSubRol.None, id = 0,
                position = Vector3.zero, byDirectHit = false, time = Time.unscaledTime, frame = Time.frameCount
            };
            CombatEvents.Killed.Dispatch(in e);
            return "dispatch Killed · 구독자=" + CombatEvents.Killed.Count;
        }

        public string Dump()
        {
            var sb = new StringBuilder();
            sb.AppendLine("LootToast subscribed=" + _subscribed + " killedSeen=" + KilledSeen +
                          " push=" + PushCount + " merge=" + MergeCount + " drop=" + DropCount +
                          " visible=" + VisibleLines);
            var sq = WLCombatTextSettings.Instance;
            sb.AppendLine("  [813c2] 상한=" + (sq != null ? sq.lootToastLines : 0) +
                          " 대기=" + _qCount + "/" + _queue.Length + " 큐버림=" + QueueDropCount +
                          " 넘침페이드=" + OverflowFadeCount + "회 · 병합창=" +
                          (sq != null ? sq.lootToastMergeSeconds.ToString("F2") : "-") + "s(보이는동안=" +
                          (sq != null ? sq.lootToastMergeWhileVisible.ToString() : "-") + ") · 페이드=" +
                          (sq != null ? sq.lootToastOverflowFadeSec.ToString("F2") : "-") + "s");
            for (int i = 0; i < _lines.Count; i++)
            {
                var l = _lines[i];
                sb.AppendLine("  [" + i + "] used=" + l.used + " item=" + l.itemId + " x" + l.count +
                              " alpha=" + l.group.alpha.ToString("F2") + " pos=" + l.rt.anchoredPosition +
                              " size=" + l.rt.sizeDelta + " font=" + l.label.fontSize.ToString("F1") +
                              " panel=" + (l.panel != null ? (l.panel.enabled ? "#" + ColorUtility.ToHtmlStringRGBA(l.panel.color) +
                                  " off" + l.panel.rectTransform.offsetMin + l.panel.rectTransform.offsetMax : "off") : "없음") +
                              " text=\"" + l.label.text + "\"");
            }
            var st = WLCombatTextSettings.Instance;
            if (st != null)
                sb.AppendLine("  설정 seconds=" + st.lootToastSeconds + "s fontPx=" + st.lootToastFontPx +
                              " widthPx=" + st.lootToastWidthPx + " lineHeightPx=" + st.lootToastLineHeightPx +
                              " rightMarginPx=" + st.lootToastRightMarginPx + " centerOffsetPx=" + st.lootToastCenterOffsetPx +
                              " panel=" + st.lootToastPanelEnabled + " 밝기하한=" + st.lootToastMinBrightness +
                              " · 등급1 태그 " + st.GradeColorTag(1) + " → " + st.GradeColorTagBright(1));
            sb.AppendLine("  clamp = " + LastClamp);
            sb.AppendLine("  edge = " + LastEdge);
            return sb.ToString();
        }

        public void SetFont(TMP_FontAsset f)
        {
            font = f;
            for (int i = 0; i < _lines.Count; i++)
                if (_lines[i].label != null && f != null) _lines[i].label.font = f;
        }
    }
}