using System.Collections.Generic;
using Spine.Unity;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;
#if UNITY_EDITOR
using UnityEditor;
#endif

public class eqpmtDesPrefab : MonoBehaviour
{
    [Header("so")]
    public equipmentSO eSO;

    [Header("display")]
    public bool displayBasicAttributes = true;
    public bool displaySpecialEffects = true;
    public bool displayTypeSameEffects = true;
    public bool displayIllusionEffects = true;
    public bool displayMaxLevelEffects = true;

    [Header("btm")]
    public Image eqpmtBtm;
    public Sprite[] eqpmtBtmSprites;

    [Header("spine particles")]
    public GameObject golden_particle;
    public GameObject red_particle;
    public GameObject pink_particle;

    [Header("head")]
    public Text eqpmtName;
    public Text eqpmtID;
    public Text eqpmtLevel;
    public Image eqpmtIcon;
    public Image eqpmtPbtm;
    public Color[] profilebtmColor;
    public Text eqpmtDescription;

    [Header("body")]
    public Text eqpmtType;
    public Text baTitle;
    public Text baDetail;
    public GameObject baSpace;
    public Text saTitle;
    public Text saDetail;
    public GameObject saSpace;
    public Text taTitle;
    public Text taDetail;
    public GameObject taSpace;
    public Text iaTitle;
    public Text iaDetail;
    public GameObject iaSpace;
    public Text mlTitle;
    public Text mlDetail;
    public GameObject eqpSpace;
    public GameObject whoEquipping;
    public Image equipperProfile;
    public Text equipperName;

    [Header("objs")]
    public GameObject eqpmtSkillPrefab;
    public Transform sasParent;
    public Transform iasParent;
    public Transform mlsParent;
    [Header("es description")]
    public GameObject esDesPrefab;
    public Vector2 esDesPrefabOffset = new Vector2(20f, 30f);

    private RectTransform rectTransform;
    private Canvas rootCanvas;
    private Camera uiCamera;
    private bool ignoreCloseUntilClickReleased;

    private void Awake()
    {
        rectTransform = transform as RectTransform;
        rootCanvas = GetComponentInParent<Canvas>();
        if (rootCanvas != null && rootCanvas.renderMode != RenderMode.ScreenSpaceOverlay)
        {
            uiCamera = rootCanvas.worldCamera;
        }
    }

    public void Bind(equipmentSO so)
    {
        eSO = so;
        RefreshView();
    }

    public void IgnoreCloseUntilClickReleased()
    {
        ignoreCloseUntilClickReleased = true;
    }

    private void Update()
    {
        if (eSO == null || rectTransform == null)
        {
            return;
        }

        if (ignoreCloseUntilClickReleased)
        {
            if (Input.GetMouseButton(0))
            {
                return;
            }

            ignoreCloseUntilClickReleased = false;
        }

        if (!Input.GetMouseButtonDown(0))
        {
            return;
        }

        if (RectTransformUtility.RectangleContainsScreenPoint(rectTransform, Input.mousePosition, uiCamera))
        {
            return;
        }

        if (IsClickInsidePopupHierarchy(Input.mousePosition))
        {
            return;
        }

        Destroy(gameObject);
    }

    private bool IsClickInsidePopupHierarchy(Vector2 screenPoint)
    {
        if (EventSystem.current == null)
        {
            return false;
        }

        PointerEventData pointer = new PointerEventData(EventSystem.current)
        {
            position = screenPoint
        };
        var results = new List<RaycastResult>();
        EventSystem.current.RaycastAll(pointer, results);
        for (int i = 0; i < results.Count; i++)
        {
            GameObject target = results[i].gameObject;
            if (target != null && target.transform.IsChildOf(transform))
            {
                return true;
            }
        }

        return false;
    }

    private void RefreshView()
    {
        ClearSkillPrefabs();

        if (eSO == null)
        {
            ApplySpineParticles(null);
            ApplyHeader(string.Empty, null, 0, string.Empty);
            ApplyBasicSection(string.Empty, false);
            ApplyEffectSection(saTitle, saDetail, saSpace, sasParent, string.Empty, null, false);
            ApplyEffectSection(taTitle, taDetail, taSpace, null, string.Empty, null, false);
            ApplyEffectSection(iaTitle, iaDetail, iaSpace, iasParent, string.Empty, null, false);
            ApplyEffectSection(mlTitle, mlDetail, null, mlsParent, string.Empty, null, false);
            ApplyEquipperInfo(null);
            return;
        }

        equipmentSO.EquipmentTierPresentation presentation = ResolveTierPresentation(eSO);
        string displayName = eSO.GetDisplayTierName();
        if (string.IsNullOrWhiteSpace(displayName))
        {
            displayName = eSO.name;
        }
        Sprite displaySprite = presentation != null ? presentation.equipmentSprite : null;
        string description = eSO.GetDisplayTierDescription();

        ApplySpineParticles(eSO);
        ApplyHeader(displayName, displaySprite, GetQualityVisualIndex(eSO), description);
        ApplyEquipperInfo(eSO);
        string basicText = BuildBasicAttributesText(eSO);
        ApplyBasicSection(basicText, displayBasicAttributes && !string.IsNullOrWhiteSpace(basicText));

        string specialText = BuildEffectText(eSO.specialEffects, out int saSkillId);
        bool hasSpecialSkill = HasSkillEffect(eSO.specialEffects);
        ApplyEffectSection(
            saTitle,
            saDetail,
            saSpace,
            sasParent,
            specialText,
            hasSpecialSkill && saSkillId > 0 ? new[] { saSkillId } : null,
            displaySpecialEffects && HasSectionContent(eSO.specialEffects, saSkillId));

        string typeSameText = BuildEffectText(eSO.typeSameEffects, out _);
        ApplyEffectSection(
            taTitle,
            taDetail,
            taSpace,
            null,
            typeSameText,
            null,
            displayTypeSameEffects && HasSectionContent(eSO.typeSameEffects, 0));

        string illusionText = BuildEffectText(eSO.illusionEffects, out int iaSkillId);
        bool isTourPreview = IsTourPreviewEquipment(eSO);
        if (isTourPreview)
        {
            illusionText = string.IsNullOrWhiteSpace(illusionText)
                ? "<color=#9DFF84>1个随机巡演特效</color>"
                : $"{illusionText}\n<color=#9DFF84>1个随机巡演特效</color>";
        }
        bool hasIllusionSkill = iaSkillId > 0;
        ApplyEffectSection(
            iaTitle,
            iaDetail,
            iaSpace,
            iasParent,
            illusionText,
            hasIllusionSkill ? new[] { iaSkillId } : null,
            displayIllusionEffects && (isTourPreview || HasSectionContent(eSO.illusionEffects, iaSkillId)));

        string maxLevelText = BuildEffectText(eSO.maxLevelEffects, out _);
        ApplyEffectSection(
            mlTitle,
            mlDetail,
            null,
            mlsParent,
            maxLevelText,
            null,
            displayMaxLevelEffects && HasSectionContent(eSO.maxLevelEffects, 0));
    }

    private void ApplySpineParticles(equipmentSO equipment)
    {
        bool showGolden = false;
        bool showRed = false;
        bool showPink = false;

        if (equipment != null)
        {
            int level = Mathf.Max(0, equipment.level);
            bool hasFinalDreamEffect = equipment.HasFinalDreamEffect();

            if (level >= 20 && hasFinalDreamEffect)
            {
                showPink = true;
            }
            else if (level >= 15)
            {
                showRed = true;
            }
            else if (level >= 10)
            {
                showGolden = true;
            }
        }

        if (golden_particle != null)
        {
            golden_particle.SetActive(showGolden);
        }

        if (red_particle != null)
        {
            red_particle.SetActive(showRed);
        }

        if (pink_particle != null)
        {
            pink_particle.SetActive(showPink);
        }
    }


    private static void ConfigureSpineParticleRenderers(GameObject target)
    {
        if (target == null)
        {
            return;
        }

        SkeletonGraphic[] skeletonGraphics = target.GetComponentsInChildren<SkeletonGraphic>(true);
        for (int i = 0; i < skeletonGraphics.Length; i++)
        {
            SkeletonGraphic skeletonGraphic = skeletonGraphics[i];
            if (skeletonGraphic == null || skeletonGraphic.allowMultipleCanvasRenderers)
            {
                continue;
            }

            skeletonGraphic.allowMultipleCanvasRenderers = true;
            skeletonGraphic.Initialize(true);
            skeletonGraphic.SetMaterialDirty();
            skeletonGraphic.SetVerticesDirty();
        }
    }
    private void ApplyEquipperInfo(equipmentSO equipment)
    {
        AllyHero_SO equipper = FindEquipper(equipment);
        bool hasEquipper = equipper != null;

        if (whoEquipping != null)
        {
            whoEquipping.SetActive(hasEquipper);
        }

        if (eqpSpace != null)
        {
            eqpSpace.SetActive(hasEquipper);
        }

        if (equipperProfile != null)
        {
            equipperProfile.sprite = hasEquipper ? equipper.ally_hero_squareProfile : null;
            equipperProfile.color = hasEquipper && equipper.ally_hero_squareProfile != null ? Color.white : new Color(1f, 1f, 1f, 0f);
        }

        if (equipperName != null)
        {
            equipperName.text = hasEquipper ? equipper.ally_heroName : string.Empty;
        }
    }

    private AllyHero_SO FindEquipper(equipmentSO equipment)
    {
        if (equipment == null)
        {
            return null;
        }

        AllyHero_SO[] heroes = LoadHeroAssets();
        for (int i = 0; i < heroes.Length; i++)
        {
            AllyHero_SO hero = heroes[i];
            if (hero == null)
            {
                continue;
            }

            hero.LoadEquippedEquipmentFromLocal();
            equipmentSO equipped = hero.GetEquippedEquipmentResolved();
            if (equipped == equipment || (!string.IsNullOrWhiteSpace(equipped?.name) && equipped.name == equipment.name))
            {
                return hero;
            }
        }

        return null;
    }

    private AllyHero_SO[] LoadHeroAssets()
    {
#if UNITY_EDITOR
        if (!Application.isPlaying)
        {
            string[] guids = AssetDatabase.FindAssets("t:AllyHero_SO", new[] { "Assets/Resources/so/ally" });
            var heroes = new List<AllyHero_SO>(guids.Length);
            for (int i = 0; i < guids.Length; i++)
            {
                string path = AssetDatabase.GUIDToAssetPath(guids[i]);
                AllyHero_SO hero = AssetDatabase.LoadAssetAtPath<AllyHero_SO>(path);
                if (hero != null)
                {
                    heroes.Add(hero);
                }
            }

            return heroes.ToArray();
        }
#endif

        return RuntimeResourcesCache.LoadAllAllyHeroes();
    }

    private equipmentSO.EquipmentTierPresentation ResolveTierPresentation(equipmentSO equipment)
    {
        if (equipment == null)
        {
            return null;
        }

        if (equipment.tierNameConfig != null &&
            equipment.tierNameConfig.TryGetStagePresentation(equipment.skillType, equipment.GetVisualTierStageIndex(), out equipmentTierNameConfigSO.StagePresentation stage) &&
            stage != null)
        {
            return new equipmentSO.EquipmentTierPresentation
            {
                tierName = stage.tierName,
                equipmentSprite = stage.equipmentSprite,
                tierDescription = stage.tierDescription
            };
        }

        return equipment.GetVisualTierPresentation();
    }

    private void ApplyHeader(string displayName, Sprite displaySprite, int qualityIndex, string description)
    {
        if (eqpmtName != null)
        {
            eqpmtName.text = displayName;
            eqpmtName.color = GetProfileColor(qualityIndex);
        }

        if (eqpmtID != null)
        {
            eqpmtID.text = BuildDisplayEquipmentId(eSO);
        }

        if (eqpmtLevel != null)
        {
            eqpmtLevel.text = eSO != null ? Mathf.Max(0, eSO.level).ToString() : string.Empty;
        }

        if (eqpmtDescription != null)
        {
            eqpmtDescription.text = description;
        }

        if (eqpmtType != null)
        {
            eqpmtType.text = eSO != null ? eSO.skillType.ToString() : string.Empty;
        }

        if (eqpmtIcon != null)
        {
            eqpmtIcon.sprite = displaySprite;
            eqpmtIcon.enabled = displaySprite != null;
        }

        if (eqpmtBtm != null)
        {
            eqpmtBtm.sprite = GetBottomSprite(qualityIndex);
            eqpmtBtm.enabled = eqpmtBtm.sprite != null;
        }

        if (eqpmtPbtm != null)
        {
            eqpmtPbtm.color = GetProfileColor(qualityIndex);
        }
    }

    private void ApplyBasicSection(string text, bool active)
    {
        SetGroupActive(baTitle, baDetail, baSpace, null, active);
        if (baDetail != null)
        {
            baDetail.supportRichText = true;
            baDetail.text = text;
            baDetail.gameObject.SetActive(active && !string.IsNullOrWhiteSpace(text));
        }
    }

    private void ApplyEffectSection(
        Text title,
        Text detail,
        GameObject space,
        Transform skillParent,
        string text,
        int[] skillIds,
        bool active)
    {
        bool hasText = !string.IsNullOrWhiteSpace(text);
        bool hasSkills = skillParent != null && skillIds != null && skillIds.Length > 0;
        bool showGroup = active && (hasText || hasSkills);

        SetGroupActive(title, detail, space, null, showGroup);
        if (detail != null)
        {
            detail.supportRichText = true;
            detail.text = text;
            detail.gameObject.SetActive(showGroup && hasText);
        }

        bool showSkillParent = showGroup && hasSkills;
        if (skillParent != null)
        {
            skillParent.gameObject.SetActive(showSkillParent);
        }

        if (!showSkillParent)
        {
            return;
        }

        for (int i = 0; i < skillIds.Length; i++)
        {
            SpawnSkillPrefab(skillParent, skillIds[i]);
        }
    }

    private void SpawnSkillPrefab(Transform parent, int skillId)
    {
        if (eqpmtSkillPrefab == null || parent == null || skillId <= 0)
        {
            return;
        }

        GameObject instance = Instantiate(eqpmtSkillPrefab, parent);
        instance.name = $"eqpmtSkill_{skillId}";
        SkillGroup skillGroup = EquipmentSkillGroupLibrary.ResolveSkillGroup(skillId);
        string displayName = skillGroup != null && !string.IsNullOrWhiteSpace(skillGroup.groupName)
            ? skillGroup.groupName
            : $"Skill {skillId}";
        Sprite displayIcon = skillGroup != null ? skillGroup.groupIcon : null;

        esPrefab legacyItem = instance.GetComponent<esPrefab>();
        if (legacyItem != null)
        {
            legacyItem.BindSkillGroup(skillId, displayName, displayIcon, esDesPrefab, transform as RectTransform, esDesPrefabOffset);

            return;
        }

        eqpmtSkillPrefabItem item = instance.GetComponent<eqpmtSkillPrefabItem>();
        if (item != null)
        {
            item.Bind(skillId);
            return;
        }

        Text[] texts = instance.GetComponentsInChildren<Text>(true);
        for (int i = 0; i < texts.Length; i++)
        {
            if (texts[i] != null)
            {
                texts[i].text = displayName;
                break;
            }
        }
    }

    private void ClearSkillPrefabs()
    {
        ClearChildren(sasParent);
        ClearChildren(iasParent);
        ClearChildren(mlsParent);
    }

    private static void ClearChildren(Transform parent)
    {
        if (parent == null)
        {
            return;
        }

        for (int i = parent.childCount - 1; i >= 0; i--)
        {
            Transform child = parent.GetChild(i);
            if (Application.isPlaying)
            {
                Destroy(child.gameObject);
            }
            else
            {
                DestroyImmediate(child.gameObject);
            }
        }
    }

    private static void SetGroupActive(Text title, Text detail, GameObject space, Transform skillParent, bool active)
    {
        if (title != null)
        {
            title.gameObject.SetActive(active);
        }

        if (detail != null)
        {
            detail.gameObject.SetActive(active);
        }

        if (space != null)
        {
            space.SetActive(active);
        }

        if (skillParent != null)
        {
            skillParent.gameObject.SetActive(active);
        }
    }

    private bool HasSectionContent(equipmentSO.EquipmentSpecialEffect[] effects, int skillId)
    {
        if (skillId > 0)
        {
            return true;
        }

        if (effects == null)
        {
            return false;
        }

        for (int i = 0; i < effects.Length; i++)
        {
            if (effects[i] != null &&
                effects[i].effectType != equipmentSO.EquipmentSpecialEffectType.Skill &&
                !Mathf.Approximately(effects[i].value, 0f))
            {
                return true;
            }
        }

        return false;
    }

    private static bool HasSkillEffect(equipmentSO.EquipmentSpecialEffect[] effects)
    {
        if (effects == null)
        {
            return false;
        }

        for (int i = 0; i < effects.Length; i++)
        {
            if (effects[i] != null && effects[i].effectType == equipmentSO.EquipmentSpecialEffectType.Skill)
            {
                return true;
            }
        }

        return false;
    }

    private string BuildBasicAttributesText(equipmentSO equipment)
    {
        if (equipment == null)
        {
            return string.Empty;
        }

        var lines = new List<string>();
        AppendBasicLine(lines, "最大生命", equipment.maxHp, equipmentSO.EquipmentSpecialEffectType.MaxHp);
        AppendBasicLine(lines, "攻击力", equipment.attack, equipmentSO.EquipmentSpecialEffectType.Attack);
        AppendBasicLine(lines, "最大法力", equipment.maxMana, equipmentSO.EquipmentSpecialEffectType.MaxMana);
        AppendBasicLine(lines, "伤害减免", equipment.damageResistance, equipmentSO.EquipmentSpecialEffectType.DamageResistance);
        AppendBasicLine(lines, "得分效率", equipment.scoreEfficiency, equipmentSO.EquipmentSpecialEffectType.ScoreEfficiency);
        return string.Join("\n", lines);
    }

    private void AppendBasicLine(List<string> lines, string label, equipmentSO.EquipmentStatTuning tuning, equipmentSO.EquipmentSpecialEffectType effectType)
    {
        if (lines == null || tuning == null)
        {
            return;
        }

        float baseValue = tuning.basicGain;
        if (Mathf.Approximately(baseValue, 0f))
        {
            return;
        }

        float levelGain = eSO != null ? Mathf.Max(0, eSO.level) * tuning.cultivationInterval : 0f;
        float finalDreamGain = GetMaxLevelBoost(effectType);
        float total = baseValue + levelGain + finalDreamGain;

        if (eSO == null || (Mathf.Max(0, eSO.level) <= 0 && Mathf.Approximately(finalDreamGain, 0f)))
        {
            lines.Add($"{label}{FormatTotalPercent(baseValue + finalDreamGain)}");
            return;
        }

        string componentText = $"<color=#ADD8E6>{FormatComponentPercent(baseValue)}</color>";
        if (!Mathf.Approximately(levelGain, 0f))
        {
            componentText += $"+<color=#F0E68C>{FormatComponentPercent(levelGain)}</color>";
        }

        if (!Mathf.Approximately(finalDreamGain, 0f))
        {
            componentText += $"+<color=#FF67A4>{FormatComponentPercent(finalDreamGain)}</color>";
        }

        lines.Add($"{label}{FormatTotalPercent(total)}  ({componentText})");
    }

    private string BuildEffectText(equipmentSO.EquipmentSpecialEffect[] effects, out int skillId)
    {
        skillId = 0;
        if (effects == eSO?.specialEffects)
        {
            skillId = eSO != null ? eSO.sa_skillID : 0;
        }
        else if (effects == eSO?.illusionEffects)
        {
            skillId = eSO != null ? eSO.ia_skillID : 0;
        }

        if (effects == null || effects.Length == 0)
        {
            return string.Empty;
        }

        bool isTypeSameEffectSection = effects == eSO?.typeSameEffects;
        bool isMaxLevelEffectSection = effects == eSO?.maxLevelEffects;
        var lines = new List<string>();
        for (int i = 0; i < effects.Length; i++)
        {
            equipmentSO.EquipmentSpecialEffect effect = effects[i];
            if (effect == null)
            {
                continue;
            }

            if (effect.effectType == equipmentSO.EquipmentSpecialEffectType.Skill)
            {
                continue;
            }

            if (Mathf.Approximately(effect.value, 0f))
            {
                continue;
            }

            string valueText = (isTypeSameEffectSection || isMaxLevelEffectSection)
                ? FormatSignedPercent(effect.value)
                : FormatSignedValue(effect.value);
            lines.Add($"{GetEffectDisplayName(effect.effectType)}{valueText}");
        }

        return string.Join("\n", lines);
    }

    private float GetMaxLevelBoost(equipmentSO.EquipmentSpecialEffectType effectType)
    {
        if (eSO == null || eSO.maxLevelEffects == null)
        {
            return 0f;
        }

        for (int i = 0; i < eSO.maxLevelEffects.Length; i++)
        {
            equipmentSO.EquipmentSpecialEffect effect = eSO.maxLevelEffects[i];
            if (effect == null || effect.effectType != effectType)
            {
                continue;
            }

            return effect.value;
        }

        return 0f;
    }

    private Sprite GetBottomSprite(int qualityIndex)
    {
        if (eqpmtBtmSprites == null || eqpmtBtmSprites.Length == 0)
        {
            return null;
        }

        int safeIndex = Mathf.Clamp(qualityIndex, 0, eqpmtBtmSprites.Length - 1);
        return eqpmtBtmSprites[safeIndex];
    }

    private Color GetProfileColor(int qualityIndex)
    {
        if (profilebtmColor == null || profilebtmColor.Length == 0)
        {
            return Color.white;
        }

        int safeIndex = Mathf.Clamp(qualityIndex, 0, profilebtmColor.Length - 1);
        return profilebtmColor[safeIndex];
    }

    private static int GetQualityVisualIndex(equipmentSO equipment)
    {
        if (equipment == null)
        {
            return 0;
        }

        return equipment.GetVisualQualityColorIndex();
    }

    private static string GetEffectDisplayName(equipmentSO.EquipmentSpecialEffectType effectType)
    {
        switch (effectType)
        {
            case equipmentSO.EquipmentSpecialEffectType.MaxHp: return "最大生命";
            case equipmentSO.EquipmentSpecialEffectType.Attack: return "攻击力";
            case equipmentSO.EquipmentSpecialEffectType.MaxMana: return "最大法力";
            case equipmentSO.EquipmentSpecialEffectType.DamageResistance: return "伤害减免";
            case equipmentSO.EquipmentSpecialEffectType.ScoreEfficiency: return "得分效率";
            case equipmentSO.EquipmentSpecialEffectType.HitManaRecovery: return "hit法力恢复";
            case equipmentSO.EquipmentSpecialEffectType.HitDamageMultiplier: return "hit伤害倍率";
            case equipmentSO.EquipmentSpecialEffectType.HpLoseBase: return "基本生命损失";
            case equipmentSO.EquipmentSpecialEffectType.Skill: return "技能";
            default: return effectType.ToString();
        }
    }

    private static string FormatTotalPercent(float value)
    {
        float percent = value * 100f;
        return $"{(percent >= 0f ? "+" : string.Empty)}{percent:0.0}%";
    }

    private static string FormatComponentPercent(float value)
    {
        float percent = value * 100f;
        return $"{percent:0.0}%";
    }

    private static string FormatSignedValue(float value)
    {
        return $"{(value >= 0f ? "+" : string.Empty)}{value:0.####}";
    }

    private static string FormatSignedPercent(float value)
    {
        float percent = value * 100f;
        return $"{(percent >= 0f ? "+" : string.Empty)}{percent:0.##}%";
    }

    private static string BuildDisplayEquipmentId(equipmentSO equipment)
    {
        if (equipment == null || string.IsNullOrWhiteSpace(equipment.name))
        {
            return string.Empty;
        }

        string raw = equipment.name;
        bool isPreview = raw.Contains("(Clone)") || raw.Contains("(TourPreview)");
        raw = raw.Replace("(Clone)", string.Empty).Replace("(TourPreview)", string.Empty).Trim();
        if (raw.StartsWith("type"))
        {
            raw = raw.Substring(4);
        }

        return isPreview ? $"{raw}(Preview)" : raw;
    }

    private static bool IsTourPreviewEquipment(equipmentSO equipment)
    {
        return equipment != null &&
               !string.IsNullOrWhiteSpace(equipment.name) &&
               equipment.name.Contains("(TourPreview)");
    }
}