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

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

        private PlayerNetworkController targetPlayer;
        private AbnormalityManager targetAbnormalityManager;
        private float abnormalityRefreshTimer;

        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();
                }
            }
        }

        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;

            // 새 타겟 구독
            SubscribeToEvents();

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

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

            targetPlayer.OnHealthChanged += HandleHealthChanged;
            targetPlayer.OnManaChanged += HandleManaChanged;
            targetPlayer.OnShieldChanged += HandleShieldChanged;

            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 (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 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();
        }
    }
}