Colosseum/Assets/_Game/Scripts/UI/PlayerHUD.cs

using System;
using System.Collections.Generic;
using System.Text;

using UnityEngine;
using TMPro;

using Colosseum.Abnormalities;
using Colosseum.Player;

namespace Colosseum.UI
{
    /// <summary>
    /// 플레이어 HUD - 체력/마나 바와 이상상태 요약 관리
    /// </summary>
    public class PlayerHUD : MonoBehaviour
    {
        [Header("Stat Bars")]
        [SerializeField] private StatBar healthBar;
        [SerializeField] private StatBar manaBar;

        [Header("Abnormality Summary")]
        [Tooltip("이상상태 요약 텍스트 (비어 있으면 런타임에 자동 생성)")]
        [SerializeField] private TMP_Text abnormalitySummaryText;

        [Tooltip("이상상태 요약 텍스트를 자동 생성할지 여부")]
        [SerializeField] private bool autoCreateAbnormalitySummary = true;

        [Header("Defense Feedback")]
        [Tooltip("방어 성공 피드백 텍스트 (비어 있으면 런타임에 자동 생성)")]
        [SerializeField] private TMP_Text defenseFeedbackText;

        [Tooltip("방어 성공 피드백 텍스트를 자동 생성할지 여부")]
        [SerializeField] private bool autoCreateDefenseFeedback = true;

        [Tooltip("일반 방어 성공 시 표시할 텍스트")]
        [SerializeField] private string guardFeedbackLabel = "방어";

        [Tooltip("완벽한 방어 성공 시 표시할 텍스트")]
        [SerializeField] private string perfectGuardFeedbackLabel = "완벽 방어";

        [Tooltip("완벽한 방어 유효 시간 동안 표시할 텍스트")]
        [SerializeField] private string perfectGuardWindowLabel = "완벽 창";

        [Tooltip("일반 방어 성공 텍스트 색상")]
        [SerializeField] private Color guardFeedbackColor = new Color(0.65f, 0.86f, 1f, 1f);

        [Tooltip("완벽한 방어 성공 텍스트 색상")]
        [SerializeField] private Color perfectGuardFeedbackColor = new Color(1f, 0.92f, 0.45f, 1f);

        [Tooltip("완벽한 방어 유효 시간 표시 색상")]
        [SerializeField] private Color perfectGuardWindowColor = new Color(0.62f, 1f, 0.88f, 1f);

        [Tooltip("방어 성공 텍스트 표시 시간")]
        [Min(0.1f)] [SerializeField] private float defenseFeedbackDuration = 0.75f;

        [Header("Passive UI")]
        [Tooltip("런타임 패시브 UI 컴포넌트를 자동으로 보정할지 여부")]
        [SerializeField] private bool autoCreatePassiveTreeUi = true;

        [Header("Target")]
        [Tooltip("자동으로 로컬 플레이어 찾기")]
        [SerializeField] private bool autoFindPlayer = true;

        private PlayerNetworkController targetPlayer;
        private AbnormalityManager targetAbnormalityManager;
        private PlayerDefenseController targetDefenseController;
        private float abnormalityRefreshTimer;
        private float defenseFeedbackRemaining;

        private const float AbnormalityRefreshInterval = 0.1f;

        /// <summary>
        /// 현재 HUD에 표시 중인 이상상태 요약 문자열
        /// </summary>
        public string CurrentAbnormalitySummary => abnormalitySummaryText != null ? abnormalitySummaryText.text : string.Empty;

        private void Awake()
        {
            EnsurePassiveTreeUi();
        }

        private void Start()
        {
            if (autoFindPlayer)
            {
                FindLocalPlayer();
            }

            EnsureAbnormalitySummaryText();
        }

        private void Update()
        {
            // 플레이어가 아직 없으면 계속 찾기
            if (targetPlayer == null && autoFindPlayer)
            {
                FindLocalPlayer();
            }

            if (targetAbnormalityManager != null)
            {
                abnormalityRefreshTimer += Time.deltaTime;
                if (abnormalityRefreshTimer >= AbnormalityRefreshInterval)
                {
                    abnormalityRefreshTimer = 0f;
                    UpdateAbnormalitySummary();
                }
            }

            UpdateDefenseFeedback();
        }

        private void OnDestroy()
        {
            // 이벤트 구독 해제
            UnsubscribeFromEvents();
        }

        private void FindLocalPlayer()
        {
            foreach (var player in FindObjectsByType<PlayerNetworkController>(FindObjectsSortMode.None))
            {
                if (player.IsOwner)
                {
                    SetTarget(player);
                    break;
                }
            }
        }

        /// <summary>
        /// 추적할 플레이어 설정
        /// </summary>
        public void SetTarget(PlayerNetworkController player)
        {
            // 이전 타겟 구독 해제
            UnsubscribeFromEvents();

            targetPlayer = player;
            targetAbnormalityManager = targetPlayer != null ? targetPlayer.GetComponent<AbnormalityManager>() : null;
            targetDefenseController = targetPlayer != null ? targetPlayer.GetComponent<PlayerDefenseController>() : null;

            // 새 타겟 구독
            SubscribeToEvents();

            // 초기 값 설정
            UpdateStatBars();
            UpdateAbnormalitySummary();
            ClearDefenseFeedback();
        }

        private void SubscribeToEvents()
        {
            if (targetPlayer == null) return;

            targetPlayer.OnHealthChanged += HandleHealthChanged;
            targetPlayer.OnManaChanged += HandleManaChanged;
            targetPlayer.OnShieldChanged += HandleShieldChanged;
            if (targetDefenseController != null)
            {
                targetDefenseController.OnDefenseStateEntered += HandleDefenseStateEntered;
                targetDefenseController.OnDefenseResolved += HandleDefenseResolved;
            }

            if (targetAbnormalityManager != null)
            {
                targetAbnormalityManager.OnAbnormalityAdded += HandleAbnormalityAdded;
                targetAbnormalityManager.OnAbnormalityRemoved += HandleAbnormalityRemoved;
                targetAbnormalityManager.OnAbnormalitiesChanged += HandleAbnormalitiesChanged;
            }
        }

        private void UnsubscribeFromEvents()
        {
            if (targetPlayer != null)
            {
                targetPlayer.OnHealthChanged -= HandleHealthChanged;
                targetPlayer.OnManaChanged -= HandleManaChanged;
                targetPlayer.OnShieldChanged -= HandleShieldChanged;
            }

            if (targetDefenseController != null)
            {
                targetDefenseController.OnDefenseStateEntered -= HandleDefenseStateEntered;
                targetDefenseController.OnDefenseResolved -= HandleDefenseResolved;
            }

            if (targetAbnormalityManager != null)
            {
                targetAbnormalityManager.OnAbnormalityAdded -= HandleAbnormalityAdded;
                targetAbnormalityManager.OnAbnormalityRemoved -= HandleAbnormalityRemoved;
                targetAbnormalityManager.OnAbnormalitiesChanged -= HandleAbnormalitiesChanged;
            }
        }

        private void HandleHealthChanged(float oldValue, float newValue)
        {
            if (healthBar != null && targetPlayer != null)
            {
                healthBar.SetValue(newValue, targetPlayer.MaxHealth, targetPlayer.Shield);
            }
        }

        private void HandleManaChanged(float oldValue, float newValue)
        {
            if (manaBar != null && targetPlayer != null)
            {
                manaBar.SetValue(newValue, targetPlayer.MaxMana);
            }
        }

        private void HandleShieldChanged(float oldValue, float newValue)
        {
            if (healthBar != null && targetPlayer != null)
            {
                healthBar.SetValue(targetPlayer.Health, targetPlayer.MaxHealth, newValue);
            }
        }

        private void HandleAbnormalityAdded(ActiveAbnormality abnormality)
        {
            UpdateAbnormalitySummary();
        }

        private void HandleAbnormalityRemoved(ActiveAbnormality abnormality)
        {
            UpdateAbnormalitySummary();
        }

        private void HandleAbnormalitiesChanged()
        {
            UpdateAbnormalitySummary();
        }

        private void UpdateStatBars()
        {
            if (targetPlayer == null) return;

            if (healthBar != null)
            {
                healthBar.SetValue(targetPlayer.Health, targetPlayer.MaxHealth, targetPlayer.Shield);
            }

            if (manaBar != null)
            {
                manaBar.SetValue(targetPlayer.Mana, targetPlayer.MaxMana);
            }
        }

        private void EnsureAbnormalitySummaryText()
        {
            if (abnormalitySummaryText != null || !autoCreateAbnormalitySummary)
                return;

            if (transform is not RectTransform parentRect)
                return;

            GameObject summaryObject = new GameObject("AbnormalitySummaryText", typeof(RectTransform));
            summaryObject.transform.SetParent(parentRect, false);

            RectTransform rectTransform = summaryObject.GetComponent<RectTransform>();
            rectTransform.anchorMin = new Vector2(1f, 1f);
            rectTransform.anchorMax = new Vector2(1f, 1f);
            rectTransform.pivot = new Vector2(1f, 1f);
            rectTransform.anchoredPosition = new Vector2(-24f, -120f);
            rectTransform.sizeDelta = new Vector2(320f, 180f);

            TextMeshProUGUI summaryText = summaryObject.AddComponent<TextMeshProUGUI>();
            summaryText.fontSize = 18f;
            summaryText.alignment = TextAlignmentOptions.TopRight;
            summaryText.textWrappingMode = TextWrappingModes.NoWrap;
            summaryText.richText = true;
            summaryText.text = string.Empty;

            TMP_FontAsset summaryFont = healthBar != null && healthBar.FontAsset != null
                ? healthBar.FontAsset
                : manaBar != null ? manaBar.FontAsset : null;

            if (summaryFont != null)
            {
                summaryText.font = summaryFont;
            }
            else if (TMP_Settings.defaultFontAsset != null)
            {
                summaryText.font = TMP_Settings.defaultFontAsset;
            }

            abnormalitySummaryText = summaryText;
        }

        private void EnsureDefenseFeedbackText()
        {
            if (defenseFeedbackText != null || !autoCreateDefenseFeedback)
                return;

            if (transform is not RectTransform parentRect)
                return;

            GameObject feedbackObject = new GameObject("DefenseFeedbackText", typeof(RectTransform));
            feedbackObject.transform.SetParent(parentRect, false);

            RectTransform rectTransform = feedbackObject.GetComponent<RectTransform>();
            rectTransform.anchorMin = new Vector2(0.5f, 0f);
            rectTransform.anchorMax = new Vector2(0.5f, 0f);
            rectTransform.pivot = new Vector2(0.5f, 0f);
            rectTransform.anchoredPosition = new Vector2(0f, 116f);
            rectTransform.sizeDelta = new Vector2(360f, 48f);

            TextMeshProUGUI feedback = feedbackObject.AddComponent<TextMeshProUGUI>();
            feedback.fontSize = 28f;
            feedback.fontStyle = FontStyles.Bold;
            feedback.alignment = TextAlignmentOptions.Center;
            feedback.textWrappingMode = TextWrappingModes.NoWrap;
            feedback.richText = true;
            feedback.alpha = 0f;
            feedback.text = string.Empty;

            TMP_FontAsset feedbackFont = healthBar != null && healthBar.FontAsset != null
                ? healthBar.FontAsset
                : manaBar != null ? manaBar.FontAsset : null;

            if (feedbackFont != null)
            {
                feedback.font = feedbackFont;
            }
            else if (TMP_Settings.defaultFontAsset != null)
            {
                feedback.font = TMP_Settings.defaultFontAsset;
            }

            defenseFeedbackText = feedback;
        }

        private void EnsurePassiveTreeUi()
        {
            if (!autoCreatePassiveTreeUi || GetComponent<PassiveTreeUI>() != null)
                return;

            gameObject.AddComponent<PassiveTreeUI>();
        }

        private void UpdateAbnormalitySummary()
        {
            if (abnormalitySummaryText == null)
            {
                EnsureAbnormalitySummaryText();
            }

            if (abnormalitySummaryText == null)
                return;

            if (targetAbnormalityManager == null)
            {
                abnormalitySummaryText.text = string.Empty;
                return;
            }

            IReadOnlyList<ActiveAbnormality> activeAbnormalities = targetAbnormalityManager.ActiveAbnormalities;
            StringBuilder builder = new StringBuilder();

            for (int i = 0; i < activeAbnormalities.Count; i++)
            {
                ActiveAbnormality abnormality = activeAbnormalities[i];
                if (abnormality?.Data == null || !abnormality.Data.showInUI)
                    continue;

                if (builder.Length > 0)
                    builder.AppendLine();

                string color = abnormality.Data.isDebuff ? "#FF7070" : "#70D0FF";
                builder.Append("<color=");
                builder.Append(color);
                builder.Append(">");
                builder.Append(abnormality.Data.abnormalityName);

                if (!abnormality.Data.IsPermanent)
                {
                    builder.Append(" ");
                    builder.Append(Mathf.CeilToInt(Mathf.Max(0f, abnormality.RemainingDuration)));
                    builder.Append("s");
                }

                builder.Append("</color>");
            }

            abnormalitySummaryText.text = builder.ToString();
        }

        private void HandleDefenseStateEntered(float perfectWindowDuration)
        {
            ShowDefenseFeedback(
                perfectGuardWindowLabel,
                perfectGuardWindowColor,
                Mathf.Max(0.05f, perfectWindowDuration));
        }

        private void HandleDefenseResolved(bool isPerfectGuard, float preventedDamage)
        {
            if (preventedDamage <= 0f)
                return;

            ShowDefenseFeedback(
                isPerfectGuard ? perfectGuardFeedbackLabel : guardFeedbackLabel,
                isPerfectGuard ? perfectGuardFeedbackColor : guardFeedbackColor,
                defenseFeedbackDuration);
        }

        private void UpdateDefenseFeedback()
        {
            if (defenseFeedbackRemaining <= 0f)
                return;

            if (defenseFeedbackText == null)
            {
                EnsureDefenseFeedbackText();
            }

            if (defenseFeedbackText == null)
                return;

            defenseFeedbackRemaining = Mathf.Max(0f, defenseFeedbackRemaining - Time.deltaTime);
            defenseFeedbackText.alpha = defenseFeedbackDuration > 0f
                ? defenseFeedbackRemaining / defenseFeedbackDuration
                : 0f;

            if (defenseFeedbackRemaining <= 0f)
            {
                defenseFeedbackText.text = string.Empty;
                defenseFeedbackText.alpha = 0f;
            }
        }

        private void ClearDefenseFeedback()
        {
            defenseFeedbackRemaining = 0f;

            if (defenseFeedbackText == null)
                return;

            defenseFeedbackText.text = string.Empty;
            defenseFeedbackText.alpha = 0f;
        }

        private void ShowDefenseFeedback(string message, Color color, float duration)
        {
            if (string.IsNullOrEmpty(message))
                return;

            if (defenseFeedbackText == null)
            {
                EnsureDefenseFeedbackText();
            }

            if (defenseFeedbackText == null)
                return;

            defenseFeedbackRemaining = Mathf.Max(0.05f, duration);
            defenseFeedbackText.text = message;
            defenseFeedbackText.color = color;
            defenseFeedbackText.alpha = 1f;
        }
    }
}