using System.Collections.Generic;
using ProjectI.Builds;
using ProjectI.Combat;
using ProjectI.Sessions;
using UnityEngine;
using UnityEngine.UIElements;

namespace ProjectI.UI
{
    [RequireComponent(typeof(UIDocument))]
    public sealed class PrototypeCombatHud : MonoBehaviour
    {
        [SerializeField] private AbilityDefinition[] abilityDefinitions;
        [SerializeField] private VisualTreeAsset buildPanel;
        [SerializeField] private VisualTreeAsset hudPanel;
        [Header("Enemy health bars")]
        [Tooltip("Seconds of received enemy health damage shown in grey behind the remaining red health. Zero disables the grey trail.")]
        [SerializeField, Range(0, 5)] private float enemyDamageTrailSeconds = .5f;

        private readonly List<AbilityDefinition> passives = new List<AbilityDefinition>();
        private readonly List<AbilityDefinition> actives = new List<AbilityDefinition>();
        private readonly List<AbilityDefinition> ultimates = new List<AbilityDefinition>();
        private readonly Dictionary<int, AbilityTuning> catalog = new Dictionary<int, AbilityTuning>();
        private readonly Dictionary<int, string> abilityNames = new Dictionary<int, string>();
        private sealed class Choice { public Button Button; public Label Marker; public int Id, Slot; }
        private readonly List<Choice> choices = new List<Choice>();
        private AbilityPickerState picker;
        private Label detailTitle;
        private VisualElement uiScreen, floatingCard;
        private Label floatingTitle, floatingBody;
        private VisualElement floatingAnchor;
        private bool floatingHovered,floatingAnchorHovered;
        private IVisualElementScheduledItem floatingLayoutTask;
        private DamageNumberPresenter damageNumbers;
        private EnemyHealthBarPresenter enemyBars;
        private RunPanels runPanels;
        private CoreInspectionPanel inspection;
        private PlayerBuffPresenter buffPresenter;
        public bool InspectionOpen=>inspection!=null&&inspection.IsOpen;
        public void ToggleInspection(){if(inspection==null)return;if(inspection.IsOpen)inspection.Close(true);else inspection.Open();}
        public void CloseInspection(bool relock=false)=>inspection?.Close(relock);
        private readonly AbilitySlotView[] abilityTiles = new AbilitySlotView[4];
        private ReticleView reticle;
        private VisualElement reticleAnchor;
        private float displayedHitTime = -10;
        private bool reticleWasVisible;
        private ProjectI.Enemies.PrototypeEncounterDirector encounter;
        private float reloadObservedDuration;
        private int reloadObservedSlot = -1;
        private readonly Label[] teammateLabels = new Label[3];
        private readonly ProgressBar[] teammateProgress = new ProgressBar[3];
        private PrototypeSessionController session;
        private PlayerBuildState preview;
        private VisualElement menu;
        private TemplateContainer buildTree;
        private TemplateContainer hudTree;
        private VisualElement hud;
        private DamageVignetteElement damageFlash;
        private VisualElement downedBanner;
        private VisualElement targetPanel;
        private Label draftStats;
        private Label draftDetails;
        private Label buildStatus;
        private Label buildFeedback;
        private Label acceptedBuild;
        private Label healthLabel;
        private Label weaponLabel;
        private Label ammoLabel;
        private Label shieldLabel, overshieldLabel, ammoCapacity, meleeLabel;
        private ProgressBar shieldBar, reloadBar, bossBar;
        private VisualElement overshieldFill;
        private Label downedText;
        private Label revivePrompt;
        private Label targetLabel;
        private Label hitDamage;
        private ProgressBar healthBar;
        private ProgressBar reviveBar;
        private ProgressBar targetBar;
        private Button applyButton;
        private Button resetButton;
        private IVisualElementScheduledItem refreshTask;
        private bool draftValid;
        private string localFeedback = "";

        private void OnEnable()
        {
            if (buildPanel == null || hudPanel == null) return;
            var root = GetComponent<UIDocument>().rootVisualElement;
            menu = root.Q("menu");
            var screen = root.Q("screen");
            if (menu == null || screen == null) return;
            session = PrototypeSessionController.Instance != null ? PrototypeSessionController.Instance : FindAnyObjectByType<PrototypeSessionController>();
            BuildCatalog();
            buildTree = buildPanel.CloneTree();
            buildTree.AddToClassList("combat-build-template");
            menu.Add(buildTree);
            hudTree = hudPanel.CloneTree();
            hudTree.AddToClassList("combat-hud-template");
            hudTree.pickingMode = PickingMode.Ignore;
            screen.Add(hudTree);
            uiScreen = screen;
            floatingCard = new ScrollView(ScrollViewMode.Vertical);
            floatingCard.AddToClassList("ability-floating-scroll");
            floatingCard.AddToClassList("ability-detail-card");
            for (int i = 0; i < buildTree.styleSheets.count; i++) floatingCard.styleSheets.Add(buildTree.styleSheets[i]);
            floatingCard.style.position = Position.Absolute;
            floatingCard.style.marginTop = 0;floatingCard.style.marginBottom = 0;
            floatingCard.style.minHeight = 0;
            floatingCard.style.display = DisplayStyle.None;
            floatingTitle = new Label(); floatingTitle.AddToClassList("combat-eyebrow");floatingTitle.AddToClassList("combat-wrap");
            floatingBody = new Label(); floatingBody.AddToClassList("combat-small"); floatingBody.AddToClassList("combat-wrap");
            floatingCard.Add(floatingTitle); floatingCard.Add(floatingBody); screen.Add(floatingCard);
            floatingCard.RegisterCallback<PointerEnterEvent>(_=>floatingHovered=true);
            floatingCard.RegisterCallback<PointerLeaveEvent>(_=>{floatingHovered=false;ScheduleHideFloatingCard();});
            floatingCard.RegisterCallback<FocusOutEvent>(_=>ScheduleHideFloatingCard());
            floatingLayoutTask=floatingCard.schedule.Execute(ResolveFloatingLayout);
            damageNumbers = new DamageNumberPresenter(screen, () => hud != null && !hud.ClassListContains("combat-hidden"));
            enemyBars = new EnemyHealthBarPresenter(screen, () => hud != null && !hud.ClassListContains("combat-hidden"), () => enemyDamageTrailSeconds);
            runPanels = new RunPanels(screen, menu, session);
            inspection=new CoreInspectionPanel(screen,session,()=>Application.isFocused&&session!=null&&session.Connected&&!session.Busy&&menu.ClassListContains("hidden")
                &&(screen.Q("settingsPanel")==null||screen.Q("settingsPanel").ClassListContains("hidden")));
            CacheControls();
            buffPresenter=new PlayerBuffPresenter(hudTree.Q("buffStrip"));
            ConfigureSelections(LocalBuildPreference.Selected);
            applyButton.clicked += ApplyBuild;
            resetButton.clicked += ResetPractice;
            if (session != null) session.Changed += Refresh;
            refreshTask = root.schedule.Execute(Refresh).Every(100);
            RefreshDraft();
            Refresh();
        }

        private void BuildCatalog()
        {
            passives.Clear();
            actives.Clear();
            ultimates.Clear();
            catalog.Clear();
            abilityNames.Clear();
            if (abilityDefinitions != null)
            {
                foreach (var definition in abilityDefinitions)
                {
                    if (definition == null || catalog.ContainsKey(definition.id)) continue;
                    catalog.Add(definition.id, definition.Tuning);
                    abilityNames.Add(definition.id, definition.displayName);
                    if (definition.slot == AbilitySlot.Passive) passives.Add(definition);
                    else if (definition.slot == AbilitySlot.Active) actives.Add(definition);
                    else if (definition.slot == AbilitySlot.Ultimate) ultimates.Add(definition);
                }
            }
            passives.Sort((a, b) => a.id.CompareTo(b.id));
            actives.Sort((a, b) => a.id.CompareTo(b.id));
            ultimates.Sort((a, b) => a.id.CompareTo(b.id));
            preview = new PlayerBuildState(catalog, new AbilityUnlockState(catalog.Keys));
        }

        private void CacheControls()
        {
            draftStats = buildTree.Q<Label>("draftStats");
            draftDetails = buildTree.Q<Label>("draftDetails");
            detailTitle = buildTree.Q<Label>("abilityDetailTitle");
            buildStatus = buildTree.Q<Label>("buildStatus");
            buildFeedback = buildTree.Q<Label>("buildFeedback");
            acceptedBuild = buildTree.Q<Label>("acceptedBuild");
            applyButton = buildTree.Q<Button>("applyBuild");
            resetButton = buildTree.Q<Button>("practiceReset");
            hud = hudTree.Q("combatHud");
            var flashPlaceholder = hudTree.Q("damageFlash");
            damageFlash = new DamageVignetteElement();
            flashPlaceholder.Add(damageFlash);
            healthLabel = hudTree.Q<Label>("healthText");
            healthBar = hudTree.Q<ProgressBar>("healthBar");
            weaponLabel = hudTree.Q<Label>("weaponText");
            ammoLabel = hudTree.Q<Label>("ammoText");
            shieldLabel = hudTree.Q<Label>("shieldText");
            overshieldLabel = hudTree.Q<Label>("overshieldText");
            shieldBar = hudTree.Q<ProgressBar>("shieldBar");
            reloadBar = hudTree.Q<ProgressBar>("reloadProgress");
            bossBar = hudTree.Q<ProgressBar>("bossHealth");
            overshieldFill = hudTree.Q("overshieldFill");
            ammoCapacity = hudTree.Q<Label>("ammoCapacity");
            meleeLabel = hudTree.Q<Label>("meleeText");
            downedBanner = hudTree.Q("downedBanner");
            downedText = hudTree.Q<Label>("downedText");
            reviveBar = hudTree.Q<ProgressBar>("localReviveProgress");
            revivePrompt = hudTree.Q<Label>("revivePrompt");
            targetPanel = hudTree.Q("targetPanel");
            targetLabel = hudTree.Q<Label>("targetText");
            targetBar = hudTree.Q<ProgressBar>("targetHealth");
            reticle = new ReticleView();
            reticleAnchor = hudTree.Q("reticleAnchor");
            reticleAnchor.Insert(0, reticle);
            string[] keys = { "Q", "F", "C", "Z" };
            for (int i = 0; i < abilityTiles.Length; i++)
            {
                abilityTiles[i] = new AbilitySlotView(keys[i], i == 3);
                hudTree.Q("abilityTiles").Add(abilityTiles[i]);
            }
            hitDamage = hudTree.Q<Label>("hitDamage");
            for (int i = 0; i < 3; i++)
            {
                teammateLabels[i] = hudTree.Q<Label>("teammate" + i);
                teammateProgress[i] = hudTree.Q<ProgressBar>("teammateProgress" + i);
            }
        }

        private void ConfigureSelections(BuildLoadout selected)
        {
            picker = new AbilityPickerState(selected);
            AddChoices(buildTree.Q("passiveChoices"), passives, -1);
            AddChoices(buildTree.Q("activeFirstChoices"), actives, 0);
            AddChoices(buildTree.Q("activeSecondChoices"), actives, 1);
            AddChoices(buildTree.Q("activeThirdChoices"), actives, 2);
            AddChoices(buildTree.Q("ultimateChoices"), ultimates, 3);
            if (passives.Count > 0) ShowDetails(passives[0]);
        }

        private void AddChoices(VisualElement parent, List<AbilityDefinition> definitions, int slot)
        {
            foreach (var definition in definitions)
            {
                var cell = new VisualElement(); cell.AddToClassList("choice-cell");
                var button = new Button(); button.AddToClassList("choice-circle");
                button.text = definition.displayName.Substring(0, System.Math.Min(2, definition.displayName.Length)).ToUpperInvariant();
                if (definition.icon != null)
                {
                    button.text = "";
                    var icon = new Image { sprite = definition.icon, scaleMode = ScaleMode.ScaleToFit };
                    icon.style.width = 40; icon.style.height = 40; button.Add(icon);
                }
                var marker = new Label(); marker.AddToClassList("choice-marker"); button.Add(marker);
                button.RegisterCallback<PointerEnterEvent>(_ => ShowDetails(definition, button,true));
                button.RegisterCallback<FocusInEvent>(_ => ShowDetails(definition, button));
                button.RegisterCallback<PointerLeaveEvent>(_ => {if(floatingAnchor==button)floatingAnchorHovered=false;ScheduleHideFloatingCard();});
                button.RegisterCallback<FocusOutEvent>(_ => ScheduleHideFloatingCard());
                button.clicked += () =>
                {
                    ShowDetails(definition, button);
                    var player = PrototypePlayerCombat.LocalPlayer;
                    if (session != null && (session.Busy || session.RunStarted) || player != null && player.Vitals.IsDowned) return;
                    if (slot < 0) picker.TogglePassive(definition.id); else if (slot == 3) picker.SelectUltimate(definition.id); else picker.SelectActive(slot, definition.id);
                    localFeedback = ""; RefreshDraft(); Refresh();
                };
                cell.Add(button);
                var name = new Label(definition.displayName); name.AddToClassList("choice-name"); cell.Add(name);
                parent.Add(cell);
                choices.Add(new Choice { Button = button, Marker = marker, Id = definition.id, Slot = slot });
            }
        }

        private void HideFloatingCard(){if(floatingCard!=null)floatingCard.style.display=DisplayStyle.None;floatingAnchor=null;floatingHovered=floatingAnchorHovered=false;}
        private void ScheduleHideFloatingCard()
        {
            floatingCard?.schedule.Execute(()=>
            {
                if(floatingCard==null)return;
                var focused=floatingCard.panel?.focusController?.focusedElement as VisualElement;
                if(!floatingHovered&&!floatingAnchorHovered&&focused!=floatingAnchor&&(focused==null||!floatingCard.Contains(focused)))HideFloatingCard();
            }).ExecuteLater(150);
        }

        private void ShowDetails(AbilityDefinition definition, VisualElement anchor = null,bool hovered=false)
        {
            detailTitle.text = definition.displayName;
            draftDetails.text = ProjectI.Menu.AbilityLibraryPresentation.Summary(definition) + "\n" + Describe(definition.Tuning);
            if (anchor == null || floatingCard == null) return;
            floatingTitle.text = definition.displayName;
            floatingBody.text = draftDetails.text;
            if(floatingAnchor!=anchor)floatingAnchorHovered=hovered;else if(hovered)floatingAnchorHovered=true;
            floatingAnchor=anchor;floatingCard.style.display=DisplayStyle.Flex;
            PositionFloatingCard();floatingCard.BringToFront();
        }
        private void PositionFloatingCard()
        {
            if(floatingAnchor==null)return;
            float maximumWidth=Mathf.Min(320,Mathf.Max(0,uiScreen.worldBound.width-16));
            float titleWidth=floatingTitle.MeasureTextSize(floatingTitle.text,0,VisualElement.MeasureMode.Undefined,0,VisualElement.MeasureMode.Undefined).x;
            float bodyWidth=floatingBody.MeasureTextSize(floatingBody.text,0,VisualElement.MeasureMode.Undefined,0,VisualElement.MeasureMode.Undefined).x;
            float width=Mathf.Min(maximumWidth,Mathf.Max(titleWidth,bodyWidth)+26);
            float textWidth=Mathf.Max(1,width-26);
            float titleHeight=floatingTitle.MeasureTextSize(floatingTitle.text,textWidth,VisualElement.MeasureMode.AtMost,0,VisualElement.MeasureMode.Undefined).y;
            float bodyHeight=floatingBody.MeasureTextSize(floatingBody.text,textWidth,VisualElement.MeasureMode.AtMost,0,VisualElement.MeasureMode.Undefined).y;
            ApplyFloatingBounds(width,Mathf.Ceil(titleHeight+bodyHeight+36));floatingLayoutTask.ExecuteLater(1);
        }
        private void ResolveFloatingLayout()
        {
            if(floatingAnchor==null||floatingCard==null||floatingTitle.layout.height<=0||floatingBody.layout.height<=0)return;
            var style=floatingCard.resolvedStyle;var titleStyle=floatingTitle.resolvedStyle;var bodyStyle=floatingBody.resolvedStyle;
            float height=floatingTitle.layout.height+floatingBody.layout.height+titleStyle.marginTop+titleStyle.marginBottom+bodyStyle.marginTop+bodyStyle.marginBottom
                +style.paddingTop+style.paddingBottom+style.borderTopWidth+style.borderBottomWidth;
            ApplyFloatingBounds(style.width,Mathf.Ceil(height));
        }
        private void ApplyFloatingBounds(float width,float naturalHeight)
        {
            var viewport=uiScreen.worldBound;var bounds=CoreInspectionPanel.PlaceDetail(viewport,floatingAnchor.worldBound,new Vector2(width,naturalHeight));
            floatingCard.style.left=bounds.x-viewport.x;floatingCard.style.top=bounds.y-viewport.y;
            floatingCard.style.width=bounds.width;floatingCard.style.height=bounds.height;floatingCard.style.maxHeight=Mathf.Max(0,viewport.height-16);
        }

        private BuildLoadout Draft => picker != null ? picker.Draft : BuildLoadout.Default;

        private void RefreshDraft()
        {
            draftValid = picker.IsValid && preview.TryEquip(Draft, false);
            draftStats.text = draftValid ? "DRAFT  " + FormatStats(preview.Stats) : "Choose two distinct passives, three distinct actives and an ultimate.";
            draftStats.EnableInClassList("combat-warning", !draftValid);
            foreach (var choice in choices)
            {
                bool selected = choice.Slot < 0 ? Draft.PassiveFirst == choice.Id || Draft.PassiveSecond == choice.Id
                    : (choice.Slot == 3 ? Draft.Ultimate : AbilityPickerState.GetActive(Draft, choice.Slot)) == choice.Id;
                choice.Button.EnableInClassList("choice-selected", selected);
                choice.Marker.text = selected ? choice.Slot < 0 ? (Draft.PassiveFirst == choice.Id ? "P1" : "P2") : "ON" : "";
            }
        }

        private static string Describe(AbilityTuning tuning)
        {
            string stats = $"HP {tuning.HealthPercent:+0%;-0%;0%}, move {tuning.MovementPercent:+0%;-0%;0%}, attack {tuning.AttackDamagePercent:+0%;-0%;0%}, ability {tuning.AbilityDamagePercent:+0%;-0%;0%}";
            if (tuning.Slot == AbilitySlot.Passive) return stats;
            string effect = tuning.Effect == AbilityEffect.Haste ? $"Move +{tuning.Magnitude:0%} for {tuning.Duration:0.#} s"
                : tuning.Effect == AbilityEffect.Dash ? $"Dodge {tuning.Magnitude:0.#} m/s for {tuning.Duration:0.#} s"
                : tuning.Effect == AbilityEffect.Barrier ? $"Grant {tuning.Magnitude:0.#} shield, overflow for {tuning.Duration:0.#} s"
                : tuning.Effect == AbilityEffect.ShieldPulse ? $"Restore {tuning.Magnitude:0.#} shield to living allies within {tuning.Radius:0.#} m, overflow for {tuning.Duration:0.#} s"
                : tuning.Effect == AbilityEffect.ArcLance ? $"Piercing energy lance, {tuning.Magnitude:0.#} damage; solid walls stop it"
                : $"{tuning.Effect}: {tuning.Magnitude:0.#} ability damage within {tuning.Radius:0.#} m";
            string restriction = tuning.Slot != AbilitySlot.Active ? "" : tuning.Effect == AbilityEffect.Dash
                ? " Dodge must finish before recasting." : tuning.Effect == AbilityEffect.Barrier
                ? " Recasts replenish one shield source." : tuning.Effect == AbilityEffect.Haste
                ? " Recasts refresh duration without stacking speed." : $" At least {tuning.MinimumCastInterval:0.##} s between casts.";
            return tuning.Slot == AbilitySlot.Ultimate ? $"Ultimate · 100 charge required; {stats}" : $"{effect}, cooldown {tuning.Cooldown:0.#} s; {stats}{restriction}";
        }

        private static string FormatStats(BuildStats stats) => $"HP {stats.MaximumHealth:0} | Move {stats.MoveSpeed:0.0} m/s | Attack {stats.AttackDamageMultiplier:0.00}x | Ability {stats.AbilityDamageMultiplier:0.00}x";

        private string AbilityName(int id) => abilityNames.TryGetValue(id, out var name) ? name : "Pending";

        private string FormatLoadout(BuildLoadout loadout) => $"{AbilityName(loadout.PassiveFirst)} + {AbilityName(loadout.PassiveSecond)} | [Q] {AbilityName(loadout.ActiveFirst)} | [F] {AbilityName(loadout.ActiveSecond)} | [C] {AbilityName(loadout.ActiveThird)} | [Z] {AbilityName(loadout.Ultimate)} | [V] {AbilityName(loadout.Melee)}";

        private void ApplyBuild()
        {
            var player = PrototypePlayerCombat.LocalPlayer;
            if (!draftValid || (session != null && (session.Busy || session.RunStarted)) || (player != null && player.Vitals != null && player.Vitals.IsDowned)) return;
            LocalBuildPreference.Selected = Draft;
            if (player != null)
            {
                player.RequestEquip(Draft);
                localFeedback = "Build requested. The server confirms your equipped stats below.";
            }
            else localFeedback = "Build selected for your next connection.";
            Refresh();
        }

        private void ResetPractice()
        {
            if (session != null && session.IsHost && !session.Busy) PrototypePlayerCombat.LocalPlayer?.RequestPracticeReset();
        }

        private void Refresh()
        {
            var player = PrototypePlayerCombat.LocalPlayer;
            bool connected = session != null && session.Connected;
            damageNumbers?.Bind(player); enemyBars?.Bind(player); runPanels?.Refresh();
            bool downed = player != null && player.Vitals != null && player.Vitals.IsDowned;
            bool locked = session != null && (session.RunStarted || session.Busy);
            if (menu.ClassListContains("hidden")) HideFloatingCard();
            foreach (var choice in choices) choice.Button.EnableInClassList("choice-locked", locked || downed);
            applyButton.SetEnabled(draftValid && !locked && !downed);
            buildStatus.text = downed ? "Build changes unavailable while downed." : locked
                ? (session.RunStarted ? "Run started: your seven slots are locked." : "Session operation in progress…")
                : "All prototype abilities unlocked. Select seven slots before the run starts.";
            buildFeedback.text = localFeedback;
            acceptedBuild.text = player != null ? "EQUIPPED  " + FormatStats(player.Stats) + "\n" + FormatLoadout(player.Loadout) + "\nServer: " + player.Feedback : "Your selected draft equips when you connect.";
            resetButton.EnableInClassList("combat-hidden", !connected || !session.IsHost);
            resetButton.SetEnabled(player != null && session != null && !session.Busy);
            bool showHud = connected && player != null && player.Vitals != null && menu.ClassListContains("hidden")
                && !ProjectI.Settings.LocalPlayerSettings.IsInputBlocked;
            hud.EnableInClassList("combat-hidden", !showHud);
            if (!showHud) return;
            RefreshVitals(player);
            RefreshWeapon(player);
            RefreshAbilities(player);
            RefreshTeammates(player);
            RefreshTarget(player);
            buffPresenter?.Refresh(player);
            if (encounter == null) encounter = FindAnyObjectByType<ProjectI.Enemies.PrototypeEncounterDirector>();
            if (encounter != null)
            {
                var state = encounter.Snapshot;
                bossBar.EnableInClassList("combat-hidden", state.BossMaximum <= 0 || state.BossHealth <= 0);
                bossBar.value = state.BossMaximum > 0 ? state.BossHealth / state.BossMaximum * 100 : 0;
                bool markedBoss = false;
                foreach (var enemy in ProjectI.Enemies.PrototypeEnemy.ActiveEnemies)
                    if (enemy != null && enemy.IsAlive && enemy.IsBoss && enemy.IsMarked) { markedBoss = true; break; }
                bossBar.title = (markedBoss ? "[SCAN] " : "") + $"Warden {state.BossHealth:0}/{state.BossMaximum:0}";
            }
        }

        private void Update()
        {
            if (reticle == null || hud == null) return;
            bool visible = !hud.ClassListContains("combat-hidden") && !ProjectI.Settings.LocalPlayerSettings.IsInputBlocked;
            reticleAnchor.EnableInClassList("combat-hidden", !visible);
            if (visible && !reticleWasVisible) reticle.MarkDirtyRepaint();
            reticleWasVisible = visible;
            var player = PrototypePlayerCombat.LocalPlayer;
            if (damageFlash != null)
            {
                float damageElapsed = player != null && player.Vitals != null
                    ? Time.unscaledTime - player.Vitals.LastDamageTakenTime : float.PositiveInfinity;
                damageFlash.SetDamageAge(visible ? damageElapsed : float.PositiveInfinity);
            }
            if (player == null || !visible) return;
            float elapsed = Time.unscaledTime - player.LastConfirmedHitTime;
            var result = player.LastDamageResult;
            reticle.SetHit(elapsed, result.Critical, result.Lethal);
            if (displayedHitTime != player.LastConfirmedHitTime)
            {
                displayedHitTime = player.LastConfirmedHitTime;
                hitDamage.text = result.HasDamage ? DamageNumberMotion.Text(result.HitDamage,result.Critical) : "";
                hitDamage.style.color = ReticleView.HitColor(result.Critical, result.Lethal);
            }
            hitDamage.EnableInClassList("combat-hidden", elapsed < 0 || elapsed >= ReticleView.LifetimeSeconds);
            if (elapsed >= 0 && elapsed < ReticleView.LifetimeSeconds) hitDamage.style.opacity = ReticleView.HitOpacity(elapsed);
        }

        private void LateUpdate()
        {
            enemyBars?.UpdateFrame(PrototypePlayerCombat.LocalPlayer?.PlayerCamera);
        }

        private void RefreshVitals(PrototypePlayerCombat player)
        {
            var vitals = player.Vitals;
            if (vitals == null) return;
            healthLabel.text = $"HP {vitals.CurrentHealth:0} / {vitals.MaximumHealth:0}";
            shieldLabel.text = $"{vitals.Shield:0} / {vitals.MaximumShield:0}";
            shieldBar.value = vitals.MaximumShield > 0 ? 100 * vitals.Shield / vitals.MaximumShield : 0;
            overshieldFill.style.width = Length.Percent(vitals.OvershieldCap > 0 ? Mathf.Clamp01(vitals.Overshield / vitals.OvershieldCap) * 100 : 0);
            overshieldLabel.text = vitals.Overshield > 0 ? $"+{vitals.Overshield:0}" : "";
            healthBar.value = vitals.MaximumHealth > 0 ? 100 * vitals.CurrentHealth / vitals.MaximumHealth : 0;
            downedBanner.EnableInClassList("combat-hidden", !vitals.IsDowned);
            downedText.text = vitals.ReviveProgress > 0 ? "TEAMMATE REVIVING YOU" : "DOWNED · A teammate must hold E nearby";
            reviveBar.value = vitals.ReviveProgress * 100;
            reviveBar.title = $"Revive {vitals.ReviveProgress * 100:0}%";
        }

        private void RefreshWeapon(PrototypePlayerCombat player)
        {
            var weapon = player.ActiveWeapon;
            weaponLabel.text = weapon != null ? $"[{player.ActiveSlot + 1}] {weapon.displayName}" : "Weapon pending";
            ammoLabel.text = weapon != null ? $"{player.Ammo}" : "—";
            ammoCapacity.text = weapon != null ? $"/ {player.MagazineCapacity}" : "";
            double remaining = player.ReloadRemaining;
            if (reloadObservedSlot != player.ActiveSlot) { reloadObservedSlot = player.ActiveSlot; reloadObservedDuration = 0; }
            reloadObservedDuration = remaining > 0 ? Mathf.Max(reloadObservedDuration, (float)remaining) : 0;
            reloadBar.EnableInClassList("combat-hidden", remaining <= 0);
            reloadBar.value = reloadObservedDuration > 0 ? 100 * (1 - (float)remaining / reloadObservedDuration) : 0;
            reloadBar.title = $"RELOAD {remaining:0.0}s";
        }

        private void RefreshAbilities(PrototypePlayerCombat player)
        {
            for (int i = 0; i < abilityTiles.Length; i++)
                abilityTiles[i].Bind(player.GetEquippedAbility(i), player.ChargesAvailable(i), player.ChargeCapacity(i), player.ChargeProgress(i), player.ChargeRemaining(i), player.Vitals.IsDowned);
            var melee = player.GetEquippedAbility(4);
            double remaining = player.ChargeRemaining(4);
            meleeLabel.text = $"[V] {(melee != null ? melee.displayName : "Melee")} · {(remaining > 0 ? $"{remaining:0.0}s" : "Ready")}";
            meleeLabel.EnableInClassList("combat-warning", player.Vitals.IsDowned);
        }

        private void RefreshTeammates(PrototypePlayerCombat local)
        {
            var players = PrototypePlayerVitals.ActivePlayers;
            int row = 0;
            PrototypePlayerVitals nearbyDowned = null;
            float nearest = 9f;
            foreach (var teammate in players)
            {
                if (teammate == null || teammate == local.Vitals) continue;
                if (row < teammateLabels.Length)
                {
                    teammateLabels[row].text = teammate.IsDowned
                        ? $"{teammate.DisplayName}  ·  DOWNED"
                        : $"{teammate.DisplayName}  ·  HP {teammate.CurrentHealth:0}/{teammate.MaximumHealth:0}  ·  Shield {teammate.Shield:0}";
                    teammateLabels[row].EnableInClassList("combat-warning", teammate.IsDowned);
                    teammateLabels[row].RemoveFromClassList("combat-hidden");
                    teammateProgress[row].value = teammate.ReviveProgress * 100;
                    teammateProgress[row].title = $"Revive {teammate.ReviveProgress * 100:0}%";
                    teammateProgress[row].EnableInClassList("combat-hidden", !teammate.IsDowned);
                    row++;
                }
                float distance = (teammate.transform.position - local.transform.position).sqrMagnitude;
                if (teammate.IsDowned && distance <= nearest)
                {
                    nearest = distance;
                    nearbyDowned = teammate;
                }
            }
            for (; row < teammateLabels.Length; row++)
            {
                teammateLabels[row].AddToClassList("combat-hidden");
                teammateProgress[row].AddToClassList("combat-hidden");
            }
            bool canRevive = nearbyDowned != null && !local.Vitals.IsDowned;
            revivePrompt.EnableInClassList("combat-hidden", !canRevive);
            if (canRevive) revivePrompt.text = $"Hold [E] to revive {nearbyDowned.DisplayName} · {nearbyDowned.ReviveProgress * 100:0}%";
        }

        private void RefreshTarget(PrototypePlayerCombat player)
        {
            IAuthoritativeDamageReceiver target = null;
            var camera = player.PlayerCamera;
            if (camera != null && Physics.Raycast(camera.transform.position, camera.transform.forward, out var hit, 90f,
                    ~LayerMask.GetMask("Players"), QueryTriggerInteraction.Ignore))
                target = hit.collider.GetComponentInParent<IAuthoritativeDamageReceiver>();
            if (target is ProjectI.Enemies.PrototypeEnemy) target = null;
            targetPanel.EnableInClassList("combat-hidden", target == null);
            if (target == null) return;
            float recent = player.RecentDamage(target.TargetId,target.Lifetime);
            targetLabel.text = $"{target.CurrentHealth:0}/{target.MaximumHealth:0} HP  |  Your recent damage {recent:0.#}";
            targetBar.value = target.MaximumHealth > 0 ? 100 * target.CurrentHealth / target.MaximumHealth : 0;
        }

        private void OnDisable()
        {
            refreshTask?.Pause();
            refreshTask = null;
            if (session != null) session.Changed -= Refresh;
            if (applyButton != null) applyButton.clicked -= ApplyBuild;
            if (resetButton != null) resetButton.clicked -= ResetPractice;
            choices.Clear();
            buildTree?.RemoveFromHierarchy();
            hudTree?.RemoveFromHierarchy();
            floatingLayoutTask?.Pause();floatingLayoutTask=null;floatingCard?.RemoveFromHierarchy(); floatingCard = null;floatingAnchor=null;
            damageNumbers?.Dispose(); damageNumbers = null;
            buffPresenter?.Dispose();buffPresenter=null;
            enemyBars?.Dispose(); enemyBars = null; inspection?.Dispose(); inspection=null; runPanels?.Dispose(); runPanels = null;
            buildTree = null;
            hudTree = null;
        }
    }
}