using UnityEngine;

[CreateAssetMenu(fileName = "EquipmentUpdateSO", menuName = "Equipment/EquipmentUpdateSO")]
public class eUpdate_mtrSO : ScriptableObject
{
    [System.Serializable]
    public class BreakthroughStageCost
    {
        [Tooltip("breakthroughMaterial required count")]
        public int materialRequired;
        [Tooltip("coin required count")]
        public int coinRequired;
    }

    [System.Serializable]
    public class PropertyTransferCost
    {
        [Tooltip("78121 required count")]
        public int transferMaterialRequired;
        [Tooltip("player_material required count")]
        public int memoryFragmentRequired;
        [Tooltip("coin required count")]
        public int coinRequired;
    }

    [Header("Material Definitions")]
    [Tooltip("Fixed equipment upgrade consumable definition: 78101")]
    public equipmentConsumableSO upgradeMaterial;
    [Tooltip("Fixed equipment breakthrough consumable definition: 78111")]
    public equipmentConsumableSO breakthroughMaterial;
    [Tooltip("Fixed equipment transfer consumable definition: 78121")]
    public equipmentConsumableSO propertyTransferMaterial;
    [Tooltip("Fixed equipment final dream consumable definition: 78131")]
    public equipmentConsumableSO finalDreamMaterial;

    [Header("Upgrade Cost")]
    [Tooltip("Upgrade material required count = base + level * growth")]
    public int upgradeMaterialBase = 1;
    public int upgradeMaterialGrowth;
    [Tooltip("Upgrade coin required count = base + level * growth")]
    public int upgradeCoinsBase;
    public int upgradeCoinsGrowth;
    [Tooltip("Upgrade memory fragment required count = base + level * growth")]
    public int upgradeMemoryFragmentBase;
    public int upgradeMemoryFragmentGrowth;

    [Header("Breakthrough Cost")]
    [Tooltip("Index 0-3 -> level 4/9/14/19")]
    public BreakthroughStageCost[] breakthroughStageCosts = new BreakthroughStageCost[4];

    [Header("Property Transfer Cost")]
    [Tooltip("Fixed cost for 记忆嘱托")]
    public PropertyTransferCost memoryEntrustCost = new PropertyTransferCost();
    [Tooltip("Index 0-4 -> level 0-4 / 5-9 / 10-14 / 15-19 / 20")]
    public PropertyTransferCost[] tourEntrustStageCosts = new PropertyTransferCost[5];

    [Header("Final Dream Cost")]
    public PropertyTransferCost finalDreamCost = new PropertyTransferCost();

    public int GetUpgradeMaterialRequired(int level)
    {
        return Mathf.Max(0, upgradeMaterialBase + Mathf.Max(0, level) * upgradeMaterialGrowth);
    }

    public int GetBreakthroughMaterialRequired(int level)
    {
        int stageIndex = GetBreakthroughStageIndex(level);
        if (stageIndex < 0 || breakthroughStageCosts == null || stageIndex >= breakthroughStageCosts.Length || breakthroughStageCosts[stageIndex] == null)
        {
            return 0;
        }

        return Mathf.Max(0, breakthroughStageCosts[stageIndex].materialRequired);
    }

    public int GetUpgradeCoinsRequired(int level)
    {
        return Mathf.Max(0, upgradeCoinsBase + Mathf.Max(0, level) * upgradeCoinsGrowth);
    }

    public int GetUpgradeMemoryFragmentRequired(int level)
    {
        return Mathf.Max(0, upgradeMemoryFragmentBase + Mathf.Max(0, level) * upgradeMemoryFragmentGrowth);
    }

    public int GetBreakthroughCoinsRequired(int level)
    {
        int stageIndex = GetBreakthroughStageIndex(level);
        if (stageIndex < 0 || breakthroughStageCosts == null || stageIndex >= breakthroughStageCosts.Length || breakthroughStageCosts[stageIndex] == null)
        {
            return 0;
        }

        return Mathf.Max(0, breakthroughStageCosts[stageIndex].coinRequired);
    }

    public int GetMemoryEntrustTransferMaterialRequired()
    {
        return memoryEntrustCost != null ? Mathf.Max(0, memoryEntrustCost.transferMaterialRequired) : 0;
    }

    public int GetMemoryEntrustMemoryFragmentRequired()
    {
        return memoryEntrustCost != null ? Mathf.Max(0, memoryEntrustCost.memoryFragmentRequired) : 0;
    }

    public int GetMemoryEntrustCoinsRequired()
    {
        return memoryEntrustCost != null ? Mathf.Max(0, memoryEntrustCost.coinRequired) : 0;
    }

    public int GetTourEntrustTransferMaterialRequired(int level)
    {
        PropertyTransferCost cost = GetTourEntrustCost(level);
        return cost != null ? Mathf.Max(0, cost.transferMaterialRequired) : 0;
    }

    public int GetTourEntrustMemoryFragmentRequired(int level)
    {
        PropertyTransferCost cost = GetTourEntrustCost(level);
        return cost != null ? Mathf.Max(0, cost.memoryFragmentRequired) : 0;
    }

    public int GetTourEntrustCoinsRequired(int level)
    {
        PropertyTransferCost cost = GetTourEntrustCost(level);
        return cost != null ? Mathf.Max(0, cost.coinRequired) : 0;
    }

    public int GetFinalDreamMaterialRequired()
    {
        return finalDreamCost != null ? Mathf.Max(0, finalDreamCost.transferMaterialRequired) : 0;
    }

    public int GetFinalDreamMemoryFragmentRequired()
    {
        return finalDreamCost != null ? Mathf.Max(0, finalDreamCost.memoryFragmentRequired) : 0;
    }

    public int GetFinalDreamCoinsRequired()
    {
        return finalDreamCost != null ? Mathf.Max(0, finalDreamCost.coinRequired) : 0;
    }

    public int GetBreakthroughStageIndex(int level)
    {
        switch (level)
        {
            case 4:
                return 0;
            case 9:
                return 1;
            case 14:
                return 2;
            case 19:
                return 3;
            default:
                return -1;
        }
    }

    public int GetTransferStageIndex(int level)
    {
        if (level < 0)
        {
            return -1;
        }

        if (level >= 20)
        {
            return 4;
        }

        if (level >= 15)
        {
            return 3;
        }

        if (level >= 10)
        {
            return 2;
        }

        if (level >= 5)
        {
            return 1;
        }

        return 0;
    }

    private PropertyTransferCost GetTourEntrustCost(int level)
    {
        int stageIndex = GetTransferStageIndex(level);
        if (stageIndex < 0 || tourEntrustStageCosts == null || stageIndex >= tourEntrustStageCosts.Length)
        {
            return null;
        }

        return tourEntrustStageCosts[stageIndex];
    }

    private void OnValidate()
    {
        if (breakthroughStageCosts == null || breakthroughStageCosts.Length != 4)
        {
            var resized = new BreakthroughStageCost[4];
            if (breakthroughStageCosts != null)
            {
                for (int i = 0; i < Mathf.Min(breakthroughStageCosts.Length, resized.Length); i++)
                {
                    resized[i] = breakthroughStageCosts[i];
                }
            }

            breakthroughStageCosts = resized;
        }

        for (int i = 0; i < breakthroughStageCosts.Length; i++)
        {
            breakthroughStageCosts[i] ??= new BreakthroughStageCost();
            breakthroughStageCosts[i].materialRequired = Mathf.Max(0, breakthroughStageCosts[i].materialRequired);
            breakthroughStageCosts[i].coinRequired = Mathf.Max(0, breakthroughStageCosts[i].coinRequired);
        }

        memoryEntrustCost ??= new PropertyTransferCost();
        memoryEntrustCost.transferMaterialRequired = Mathf.Max(0, memoryEntrustCost.transferMaterialRequired);
        memoryEntrustCost.memoryFragmentRequired = Mathf.Max(0, memoryEntrustCost.memoryFragmentRequired);
        memoryEntrustCost.coinRequired = Mathf.Max(0, memoryEntrustCost.coinRequired);

        if (tourEntrustStageCosts == null || tourEntrustStageCosts.Length != 5)
        {
            var resized = new PropertyTransferCost[5];
            if (tourEntrustStageCosts != null)
            {
                for (int i = 0; i < Mathf.Min(tourEntrustStageCosts.Length, resized.Length); i++)
                {
                    resized[i] = tourEntrustStageCosts[i];
                }
            }

            tourEntrustStageCosts = resized;
        }

        for (int i = 0; i < tourEntrustStageCosts.Length; i++)
        {
            tourEntrustStageCosts[i] ??= new PropertyTransferCost();
            tourEntrustStageCosts[i].transferMaterialRequired = Mathf.Max(0, tourEntrustStageCosts[i].transferMaterialRequired);
            tourEntrustStageCosts[i].memoryFragmentRequired = Mathf.Max(0, tourEntrustStageCosts[i].memoryFragmentRequired);
            tourEntrustStageCosts[i].coinRequired = Mathf.Max(0, tourEntrustStageCosts[i].coinRequired);
        }

        finalDreamCost ??= new PropertyTransferCost();
        finalDreamCost.transferMaterialRequired = Mathf.Max(0, finalDreamCost.transferMaterialRequired);
        finalDreamCost.memoryFragmentRequired = Mathf.Max(0, finalDreamCost.memoryFragmentRequired);
        finalDreamCost.coinRequired = Mathf.Max(0, finalDreamCost.coinRequired);
    }
}