using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using Bansonic;
#if UNITY_EDITOR
using UnityEditor;
#endif

public class equipSmelt : MonoBehaviour
{
    private static readonly List<equipmentSO> SmeltPoolEquipments = new List<equipmentSO>();
    private static readonly HashSet<equipmentSO> SmeltPoolLookup = new HashSet<equipmentSO>();
    private static readonly HashSet<equipmentSO> ConsumedSmeltEquipments = new HashSet<equipmentSO>();
    private static readonly List<equipSmelt> Instances = new List<equipSmelt>();

    private static bool isSmeltingState;
    private static bool smeltCompletedState;
    private static int gamesRequiredForCurrentBatchState;
    private static int gamesCompletedForCurrentBatchState;
    private static int pendingDirectFragmentsState;
    private static int pendingStoredFragmentsState;
    private static int storedSmeltEnergyState;

    [Header("so")]
    public smeltStageRewardSO ssrso;

    [Header("sprites")]
    public Sprite memoryFragment;
    public Sprite coins;

    [Header("selection and progress")]
    public GameObject smeltPool;
    public GameObject smeltProgress;

    [Header("drag")]
    public GameObject dragObj;

    [Header("smeltPool")]
    public GameObject smeltPoolItemPrefab;
    public Transform smeltPoolContent;

    [Header("smeltTimeProgress")]
    public Slider stpSlider;
    public Text smeltStatusText;
    public Button quickFinishButton;
    public Text qf_cost_text;

    [Header("smelt Rewards")]
    public Text rewardGenProgress;
    public Image rewardProgressImage;
    public Dropdown selectAReward;
    public Button getReward;

    [Header("smelt notice")]
    public Image d_mf_img;
    public Text d_mf_Amount;
    public Image s_mf_img;
    public Text s_mf_Amount;
    public Text smeltNoticeText;

    [Header("cost and start")]
    public Text costText;
    public Text reasonWhy;
    public Button startSmeltButton;

    [Header("choose type and skill")]
    public GameObject ctasPrefab;
    public Transform ctasParent;

    private readonly List<GameObject> spawnedPoolItems = new List<GameObject>();

    private void Awake()
    {
        RegisterInstance();
        BindButtons();
        RefreshAllUi();
    }

    private void OnEnable()
    {
        RegisterInstance();
        BindButtons();
        settlementController.OnSettlementCompleted -= HandleSettlementCompleted;
        settlementController.OnSettlementCompleted += HandleSettlementCompleted;
        RefreshAllUi();
    }

    private void OnDisable()
    {
        settlementController.OnSettlementCompleted -= HandleSettlementCompleted;
        Instances.Remove(this);
    }

    private void OnDestroy()
    {
        settlementController.OnSettlementCompleted -= HandleSettlementCompleted;
        Instances.Remove(this);
    }

    public static bool IsEquipmentAssignedToSmeltPool(equipmentSO equipment)
    {
        return equipment != null && SmeltPoolLookup.Contains(equipment);
    }

    public static bool IsEquipmentConsumedBySmelt(equipmentSO equipment)
    {
        return equipment != null && ConsumedSmeltEquipments.Contains(equipment);
    }

    public static bool RemoveEquipmentFromSmeltPool(equipmentSO equipment)
    {
        if (equipment == null)
        {
            return false;
        }

        if (!SmeltPoolLookup.Remove(equipment))
        {
            return false;
        }

        SmeltPoolEquipments.Remove(equipment);
        RefreshAllSmeltPools();
        RefreshAllEquipBags();
        return true;
    }

    public static bool TryHandleQuickTransfer(equipmentSO equipment)
    {
        if (equipment == null || IsEquipmentConsumedBySmelt(equipment))
        {
            return false;
        }

        equipSmelt activeSmelt = GetActivePoolInstance();
        if (activeSmelt == null)
        {
            return false;
        }

        if (IsEquipmentAssignedToSmeltPool(equipment))
        {
            return RemoveEquipmentFromSmeltPool(equipment);
        }

        activeSmelt.AcceptDraggedEquipment(equipment);
        return IsEquipmentAssignedToSmeltPool(equipment);
    }

    public void SetDragPreviewVisible(bool visible)
    {
        if (dragObj == null)
        {
            return;
        }

        if (!IsPoolOpenForTransfers())
        {
            dragObj.SetActive(false);
            return;
        }

        bool shouldShow = visible || SmeltPoolEquipments.Count == 0;
        dragObj.SetActive(shouldShow);
    }

    public bool IsPointerOverDropArea(Vector2 screenPoint, Camera eventCamera)
    {
        if (dragObj == null || !dragObj.activeInHierarchy || !IsPoolOpenForTransfers())
        {
            return false;
        }

        RectTransform[] rects = dragObj.GetComponentsInChildren<RectTransform>(true);
        if (rects == null || rects.Length == 0)
        {
            return false;
        }

        for (int i = 0; i < rects.Length; i++)
        {
            RectTransform rect = rects[i];
            if (rect == null || !rect.gameObject.activeInHierarchy)
            {
                continue;
            }

            if (RectTransformUtility.RectangleContainsScreenPoint(rect, screenPoint, eventCamera))
            {
                return true;
            }
        }

        return false;
    }

    public void AcceptDraggedEquipment(equipmentSO equipment)
    {
        if (equipment == null || IsEquipmentConsumedBySmelt(equipment) || !IsPoolOpenForTransfers())
        {
            return;
        }

        int capacity = GetSmeltEquipmentCapacity();
        if (capacity <= 0 || SmeltPoolEquipments.Count >= capacity)
        {
            return;
        }

        if (SmeltPoolLookup.Add(equipment))
        {
            SmeltPoolEquipments.Add(equipment);
            RefreshAllUi();
            RefreshAllEquipBags();
        }
    }

    private void BindButtons()
    {
        if (startSmeltButton != null)
        {
            startSmeltButton.onClick.RemoveListener(HandleStartSmeltClicked);
            startSmeltButton.onClick.AddListener(HandleStartSmeltClicked);
        }

        if (quickFinishButton != null)
        {
            quickFinishButton.onClick.RemoveListener(HandleQuickFinishClicked);
            quickFinishButton.onClick.AddListener(HandleQuickFinishClicked);
        }

        if (getReward != null)
        {
            getReward.onClick.RemoveListener(HandleGetRewardClicked);
            getReward.onClick.AddListener(HandleGetRewardClicked);
        }

        if (selectAReward != null)
        {
            selectAReward.onValueChanged.RemoveListener(HandleRewardSelectionChanged);
            selectAReward.onValueChanged.AddListener(HandleRewardSelectionChanged);
        }
    }

    private void HandleStartSmeltClicked()
    {
        if (smeltCompletedState)
        {
            ClaimCurrentBatchRewards();
            return;
        }

        if (isSmeltingState || SmeltPoolEquipments.Count <= 0)
        {
            return;
        }

        isSmeltingState = true;
        smeltCompletedState = false;
        gamesCompletedForCurrentBatchState = 0;
        gamesRequiredForCurrentBatchState = Mathf.Max(1, Mathf.CeilToInt(SmeltPoolEquipments.Count / 20f));

        int totalFragments = CalculateTotalFragmentsForCurrentPool();
        pendingDirectFragmentsState = Mathf.FloorToInt(totalFragments * 0.7f);
        pendingStoredFragmentsState = Mathf.Max(0, totalFragments - pendingDirectFragmentsState);

        ConsumeCurrentPoolEquipments();
        RefreshAllUi();
        RefreshAllEquipBags();
    }

    private void HandleQuickFinishClicked()
    {
        if (!isSmeltingState || smeltCompletedState)
        {
            return;
        }

        int cost = GetQuickFinishCost();
        if (!PlayerEconomyLedger.EnsureInstance().TrySpendCoins(cost))
        {
            return;
        }

        gamesCompletedForCurrentBatchState = gamesRequiredForCurrentBatchState;
        smeltCompletedState = true;
        RefreshAllUi();
    }

    private void HandleSettlementCompleted()
    {
        if (!isSmeltingState || smeltCompletedState)
        {
            return;
        }

        gamesCompletedForCurrentBatchState = Mathf.Min(gamesRequiredForCurrentBatchState, gamesCompletedForCurrentBatchState + 1);
        if (gamesCompletedForCurrentBatchState >= gamesRequiredForCurrentBatchState)
        {
            smeltCompletedState = true;
        }

        RefreshAllUi();
    }

    private void ClaimCurrentBatchRewards()
    {
        if (!smeltCompletedState)
        {
            return;
        }

        if (pendingDirectFragmentsState > 0)
        {
            PlayerEconomyLedger.EnsureInstance().AddMaterial(pendingDirectFragmentsState);
        }

        storedSmeltEnergyState = Mathf.Clamp(storedSmeltEnergyState + pendingStoredFragmentsState, 0, GetSmeltStorageCapacity());

        pendingDirectFragmentsState = 0;
        pendingStoredFragmentsState = 0;
        gamesRequiredForCurrentBatchState = 0;
        gamesCompletedForCurrentBatchState = 0;
        isSmeltingState = false;
        smeltCompletedState = false;

        if (d_mf_Amount != null)
        {
            d_mf_Amount.text = "0";
        }

        if (s_mf_Amount != null)
        {
            s_mf_Amount.text = "0";
        }

        RefreshAllUi();
        RefreshAllEquipBags();
    }

    private void HandleGetRewardClicked()
    {
        smeltStageRewardSO.SmeltStageRewardRequirement requirement = GetSelectedRewardRequirement();
        if (requirement == null)
        {
            return;
        }

        int requiredAmount = Mathf.Max(0, requirement.requiredAmount);
        if (requiredAmount > storedSmeltEnergyState)
        {
            return;
        }

        equipmentSO generated = equipmentGenerator.GenerateFromSmeltReward(ssrso, requirement);
        if (generated == null)
        {
            return;
        }

        storedSmeltEnergyState = Mathf.Max(0, storedSmeltEnergyState - requiredAmount);
        RefreshAllUi();
        RefreshAllEquipBags();
    }

    private void HandleRewardSelectionChanged(int _)
    {
        RefreshButtons();
    }

    private void ConsumeCurrentPoolEquipments()
    {
        if (SmeltPoolEquipments.Count == 0)
        {
            return;
        }

        for (int i = 0; i < SmeltPoolEquipments.Count; i++)
        {
            equipmentSO equipment = SmeltPoolEquipments[i];
            if (equipment == null)
            {
                continue;
            }

            ConsumedSmeltEquipments.Add(equipment);

#if UNITY_EDITOR
            string assetPath = AssetDatabase.GetAssetPath(equipment);
            if (!string.IsNullOrWhiteSpace(assetPath) && assetPath.StartsWith("Assets/Resources/so/uEquip/", StringComparison.OrdinalIgnoreCase))
            {
                AssetDatabase.DeleteAsset(assetPath);
            }
#endif
        }

        SmeltPoolEquipments.Clear();
        SmeltPoolLookup.Clear();

#if UNITY_EDITOR
        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();
#endif
    }

    private void RefreshAllUi()
    {
        ApplySmeltViewState();
        RebuildSmeltPool();
        RefreshRewardPreview();
        RefreshStoredEnergyDisplay();
        RefreshRewardDropdown();
        RefreshProgressDisplay();
        RefreshButtons();
        RefreshReasonWhy();
    }

    private void ApplySmeltViewState()
    {
        if (smeltPool != null)
        {
            smeltPool.SetActive(!isSmeltingState);
        }

        if (smeltProgress != null)
        {
            smeltProgress.SetActive(isSmeltingState);
        }

        SetDragPreviewVisible(false);
    }

    private bool IsPoolOpenForTransfers()
    {
        return gameObject.activeInHierarchy && smeltPool != null && smeltPool.activeInHierarchy && !isSmeltingState;
    }

    private void RebuildSmeltPool()
    {
        ClearSmeltPoolItems();

        if (smeltPoolItemPrefab == null || smeltPoolContent == null)
        {
            SetDragPreviewVisible(false);
            return;
        }

        for (int i = 0; i < SmeltPoolEquipments.Count; i++)
        {
            equipmentSO equipment = SmeltPoolEquipments[i];
            if (equipment == null)
            {
                continue;
            }

            GameObject instance = Instantiate(smeltPoolItemPrefab, smeltPoolContent);
            instance.name = string.IsNullOrWhiteSpace(equipment.GetCurrentTierDisplayName()) ? equipment.name : equipment.GetCurrentTierDisplayName();
            instance.SetActive(true);
            spawnedPoolItems.Add(instance);

            equipItemPrefab item = instance.GetComponent<equipItemPrefab>();
            if (item != null)
            {
                item.Bind(equipment);
            }
        }

        int placeholderToSpawn = Mathf.Max(0, GetSmeltEquipmentCapacity() - SmeltPoolEquipments.Count);
        for (int i = 0; i < placeholderToSpawn; i++)
        {
            GameObject instance = Instantiate(smeltPoolItemPrefab, smeltPoolContent);
            instance.name = $"SmeltPlaceholder_{i:00}";
            instance.SetActive(true);
            spawnedPoolItems.Add(instance);

            equipItemPrefab item = instance.GetComponent<equipItemPrefab>();
            if (item != null)
            {
                item.Bind(null);
                if (item.itemButton != null)
                {
                    item.itemButton.interactable = false;
                }
            }
        }

        SetDragPreviewVisible(false);
    }

    private void RefreshRewardPreview()
    {
        bool useLockedBatchReward = isSmeltingState || smeltCompletedState;

        int directReward;
        int savedReward;

        if (useLockedBatchReward)
        {
            directReward = Mathf.Max(0, pendingDirectFragmentsState);
            savedReward = Mathf.Max(0, pendingStoredFragmentsState);
        }
        else
        {
            int totalFragments = CalculateTotalFragmentsForCurrentPool();
            directReward = Mathf.FloorToInt(totalFragments * 0.7f);
            savedReward = Mathf.Max(0, totalFragments - directReward);
        }

        if (d_mf_Amount != null)
        {
            d_mf_Amount.text = directReward.ToString();
        }

        if (s_mf_Amount != null)
        {
            s_mf_Amount.text = savedReward.ToString();
        }
    }

    private void RefreshProgressDisplay()
    {
        if (qf_cost_text != null)
        {
            qf_cost_text.text = GetQuickFinishCost().ToString();
        }

        if (stpSlider != null)
        {
            int required = Mathf.Max(1, gamesRequiredForCurrentBatchState);
            stpSlider.minValue = 0f;
            stpSlider.maxValue = required;
            stpSlider.value = Mathf.Clamp(gamesCompletedForCurrentBatchState, 0, required);

            Text sliderText = stpSlider.GetComponentInChildren<Text>(true);
            if (sliderText != null)
            {
                sliderText.text = $"融合进度{Mathf.Clamp(gamesCompletedForCurrentBatchState, 0, required)}/{required}";
            }
        }

        if (smeltStatusText != null)
        {
            if (!isSmeltingState)
            {
                smeltStatusText.text = string.Empty;
            }
            else if (smeltCompletedState)
            {
                smeltStatusText.text = "融合完毕，可以收获结果";
            }
            else
            {
                int remain = Mathf.Max(0, gamesRequiredForCurrentBatchState - gamesCompletedForCurrentBatchState);
                smeltStatusText.text = $"正在融合，还需{remain}场比赛";
            }
        }
    }

    private void RefreshStoredEnergyDisplay()
    {
        int capacity = GetSmeltStorageCapacity();
        if (rewardGenProgress != null)
        {
            rewardGenProgress.text = $"{storedSmeltEnergyState}/{capacity}";
        }

        if (rewardProgressImage != null)
        {
            rewardProgressImage.fillAmount = capacity <= 0 ? 0f : Mathf.Clamp01((float)storedSmeltEnergyState / capacity);
        }
    }

    private void RefreshRewardDropdown()
    {
        if (selectAReward == null)
        {
            return;
        }

        selectAReward.ClearOptions();
        if (selectAReward.captionText != null)
        {
            selectAReward.captionText.supportRichText = true;
        }

        if (selectAReward.itemText != null)
        {
            selectAReward.itemText.supportRichText = true;
        }

        var options = new List<Dropdown.OptionData>();
        if (ssrso != null && ssrso.rewardRequirements != null)
        {
            for (int i = 0; i < ssrso.rewardRequirements.Length; i++)
            {
                smeltStageRewardSO.SmeltStageRewardRequirement requirement = ssrso.rewardRequirements[i];
                string optionName = requirement != null ? requirement.equipRewardName : string.Empty;
                int requiredAmount = requirement != null ? Mathf.Max(0, requirement.requiredAmount) : 0;
                string color = string.IsNullOrWhiteSpace(optionName)
                    ? "#808080"
                    : (requiredAmount > storedSmeltEnergyState ? "#FF0000" : "#FFFFFF");
                options.Add(new Dropdown.OptionData($"<color={color}>{(string.IsNullOrWhiteSpace(optionName) ? "未命名奖励" : optionName)}</color>"));
            }
        }

        if (options.Count == 0)
        {
            options.Add(new Dropdown.OptionData("<color=#808080>暂无奖励</color>"));
        }

        selectAReward.AddOptions(options);
        selectAReward.value = 0;
        selectAReward.RefreshShownValue();
    }

    private void RefreshButtons()
    {
        if (startSmeltButton != null)
        {
            startSmeltButton.interactable = smeltCompletedState || (!isSmeltingState && SmeltPoolEquipments.Count > 0);
            Text startButtonText = startSmeltButton.GetComponentInChildren<Text>(true);
            if (startButtonText != null)
            {
                startButtonText.text = smeltCompletedState ? "领取碎片" : "开始融合";
            }
        }

        if (quickFinishButton != null)
        {
            quickFinishButton.interactable = isSmeltingState && !smeltCompletedState && PlayerEconomyLedger.EnsureInstance().HasEnoughCoins(GetQuickFinishCost());
        }

        if (getReward != null)
        {
            smeltStageRewardSO.SmeltStageRewardRequirement requirement = GetSelectedRewardRequirement();
            getReward.interactable = requirement != null && Mathf.Max(0, requirement.requiredAmount) <= storedSmeltEnergyState;
        }
    }

    private void RefreshReasonWhy()
    {
        if (reasonWhy == null)
        {
            return;
        }

        if (smeltCompletedState)
        {
            reasonWhy.text = string.Empty;
            return;
        }

        if (isSmeltingState)
        {
            reasonWhy.text = "正在融合中";
            return;
        }

        if (GetSmeltEquipmentCapacity() <= 0)
        {
            reasonWhy.text = "熔炉容量为0";
            return;
        }

        if (SmeltPoolEquipments.Count <= 0)
        {
            reasonWhy.text = "需要投入记忆";
            return;
        }

        reasonWhy.text = string.Empty;
    }

    private int CalculateTotalFragmentsForCurrentPool()
    {
        int totalFragments = 0;
        for (int i = 0; i < SmeltPoolEquipments.Count; i++)
        {
            equipmentSO equipment = SmeltPoolEquipments[i];
            if (equipment == null)
            {
                continue;
            }

            totalFragments += GetFragmentReward(equipment);
        }

        return totalFragments;
    }

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

        int skillCount = 0;
        if (equipment.sa_skillID > 0)
        {
            skillCount++;
        }

        if (equipment.ia_skillID > 0)
        {
            skillCount++;
        }

        int simpleReward = ssrso != null ? ssrso.simpleRewardAmount : 40;
        int oneSkillReward = ssrso != null ? ssrso._1skillRewardAmount : 100;
        int twoSkillReward = ssrso != null ? ssrso._2skillRewardAmount : 300;

        switch (skillCount)
        {
            case 0: return simpleReward;
            case 1: return oneSkillReward;
            default: return twoSkillReward;
        }
    }

    private int GetSmeltEquipmentCapacity()
    {
        if (ssrso == null)
        {
            return 60;
        }

        return Mathf.Clamp(ssrso.smeltEquipmentCapacity, 0, 100);
    }

    private int GetSmeltStorageCapacity()
    {
        if (ssrso == null)
        {
            return 5000;
        }

        return Mathf.Clamp(ssrso.smeltStorageCapacity, 0, 5000);
    }

    private int GetQuickFinishCost()
    {
        return ssrso != null ? Mathf.Max(0, ssrso.quickFinishCost) : 0;
    }

    private smeltStageRewardSO.SmeltStageRewardRequirement GetSelectedRewardRequirement()
    {
        if (ssrso == null || ssrso.rewardRequirements == null || ssrso.rewardRequirements.Length == 0)
        {
            return null;
        }

        int selectedIndex = selectAReward != null ? Mathf.Clamp(selectAReward.value, 0, ssrso.rewardRequirements.Length - 1) : 0;
        return ssrso.rewardRequirements[selectedIndex];
    }

    private static equipSmelt GetActivePoolInstance()
    {
        for (int i = 0; i < Instances.Count; i++)
        {
            equipSmelt instance = Instances[i];
            if (instance != null && instance.IsPoolOpenForTransfers())
            {
                return instance;
            }
        }

        return null;
    }

    private void ClearSmeltPoolItems()
    {
        for (int i = smeltPoolContent != null ? smeltPoolContent.childCount - 1 : -1; i >= 0; i--)
        {
            Transform child = smeltPoolContent.GetChild(i);
            if (child == null)
            {
                continue;
            }

#if UNITY_EDITOR
            if (!Application.isPlaying)
            {
                DestroyImmediate(child.gameObject);
            }
            else
#endif
            {
                Destroy(child.gameObject);
            }
        }

        spawnedPoolItems.Clear();
    }

    private void RegisterInstance()
    {
        if (!Instances.Contains(this))
        {
            Instances.Add(this);
        }
    }

    private static void RefreshAllSmeltPools()
    {
        for (int i = 0; i < Instances.Count; i++)
        {
            if (Instances[i] != null)
            {
                Instances[i].RefreshAllUi();
            }
        }
    }

    private static void RefreshAllEquipBags()
    {
        equipBag[] bags = FindObjectsOfType<equipBag>(true);
        if (bags == null)
        {
            return;
        }

        for (int i = 0; i < bags.Length; i++)
        {
            if (bags[i] != null)
            {
                bags[i].Rebuild();
            }
        }
    }
}