using System.Collections.Generic;
using System.Linq;
using Continentis.MainGame.Rules;
using SLSFramework.General;
using Unity.VisualScripting;
using UnityEngine;

namespace Continentis.MainGame.Character
{
    public partial class AttributeSubmodule : SubmoduleBase<CharacterBase>
    {
        public AttributeGroup coreAttributeGroup;
        public AttributeGroup generalAttributeGroup;

        public AttributeSubmodule(CharacterBase character) : base(character)
        {
            Initialize(character.data);
        }

        private void Initialize(CharacterData characterData)
        {
            coreAttributeGroup = new AttributeGroup(characterData.coreAttributes);
            generalAttributeGroup = new AttributeGroup(characterData.generalAttributes);
           
            RulesManager.Instance.attributeRulesMerger.convertCoreIntoGeneral(coreAttributeGroup.current, generalAttributeGroup.original);
            generalAttributeGroup.ApplyAllAttributes();
            generalAttributeGroup.SetUpEndowments(characterData.runtimeGeneralAttributes);
        }
    }
    
    public partial class AttributeSubmodule
    {
        public float GetCurrentCoreAttribute(string attributeName, float defaultValue = 0)
        {
            return coreAttributeGroup.current.GetValueOrDefault(attributeName, defaultValue);
        }
        
        public int GetRoundCurrentCoreAttribute(string attributeName, int defaultValue = 0)
        {
            return coreAttributeGroup.current.GetRoundValue(attributeName, defaultValue);
        }
        
        public float GetCurrentGeneralAttribute(string attributeName, float defaultValue = 0)
        {
            return generalAttributeGroup.current.GetValueOrDefault(attributeName, defaultValue);
        }
        
        public int GetRoundCurrentGeneralAttribute(string attributeName, int defaultValue = 0)
        {
            return generalAttributeGroup.current.GetRoundValue(attributeName, defaultValue);
        }
    }

    public partial class AttributeSubmodule
    {
        /// <summary>
        /// 得出对某个核心属性的检定成功概率
        /// 计算方式为：达到需求值为100%，每低于1点属性值，成功率降低20%。
        /// </summary>
        /// <param name="coreAttributeName">属性名</param>
        /// <param name="requirement">需求值</param>
        /// <param name="higherPass">设true为高于需求值算作通过（probability），如果为false，则最终概率为（1-probability）</param>
        /// <param name="additionalAmount">额外加成</param>
        /// <returns>最终概率</returns>
        public float Probability(string coreAttributeName, int requirement, bool higherPass = true, int additionalAmount = 0)
        {
            return Probability(GetRoundCurrentCoreAttribute(coreAttributeName), requirement, higherPass, additionalAmount);
        }

        /// <summary>
        /// 对某个核心属性进行检定
        /// </summary>
        /// <param name="coreAttributeName">属性名</param>
        /// <param name="requirement">需求值</param>
        /// <param name="higherPass">设true为高于需求值算作通过（probability），如果为false，则最终概率为（1-probability）</param>
        /// <param name="additionalAmount">额外加成</param>
        /// <returns>本次检定是否通过</returns>
        public bool Check(string coreAttributeName, int requirement, bool higherPass = true, int additionalAmount = 0)
        {
            return Check(GetRoundCurrentCoreAttribute(coreAttributeName), requirement, higherPass, additionalAmount);
        }

        private float Calculate(int value, int requirement)
        {
            int difference = value - requirement;
            return Mathf.Clamp01(1 + difference * 0.2f);
        }

        private float Probability(int attributeValue, int requirement, bool higherPass = true, int additionalAmount = 0)
        {
            float probability = Calculate(attributeValue + additionalAmount, requirement);
            return higherPass ? probability : 1 - probability;
        }

        private bool Check(int attributeValue, int requirement, bool higherPass = true, int additionalAmount = 0)
        {
            float baseProbability = Probability(attributeValue, requirement, higherPass, additionalAmount);
            return baseProbability >= Random.Range(0f, 1f);
        }
    }

    public partial class AttributeSubmodule
    {
        public void RefreshCoreAttribute(string attributeName)
        {
            coreAttributeGroup.ResetAttribute(attributeName);
            
            owner.equipmentSubmodule.GetCoreAttributeChange(attributeName, out float e_numeric, out float e_pAccumulation, out float e_pMultiplication);
            owner.combatBuffSubmodule.GetCoreAttributeChange(attributeName, out float cb_numeric, out float cb_pAccumulation, out float cb_pMultiplication);
            
            float numeric = e_numeric + cb_numeric;
            float pAccumulation = e_pAccumulation + cb_pAccumulation;
            float pMultiplication = e_pMultiplication * cb_pMultiplication;
            coreAttributeGroup.ModifyAttribute(attributeName, numeric, pAccumulation, pMultiplication);
            
            RulesManager.Instance.attributeRulesMerger.convertCoreIntoGeneral(coreAttributeGroup.current, generalAttributeGroup.original);
        }
        
        public void RefreshAllCoreAttributes()
        {
            foreach (string attributeName in coreAttributeGroup.current.Keys)
            {
                RefreshCoreAttribute(attributeName);
            }
        }
    }

    public partial class AttributeSubmodule
    {
        public void RefreshGeneralAttribute(string attributeName)
        {
            generalAttributeGroup.ResetAttribute(attributeName);
            
            owner.equipmentSubmodule.GetGeneralAttributeChange(attributeName, out float e_numeric, out float e_pAccumulation, out float e_pMultiplication);
            owner.combatBuffSubmodule.GetGeneralAttributeChange(attributeName, out float cb_numeric, out float cb_pAccumulation, out float cb_pMultiplication);
            
            float numeric = e_numeric + cb_numeric;
            float pAccumulation = e_pAccumulation + cb_pAccumulation;
            float pMultiplication = e_pMultiplication * cb_pMultiplication;
            generalAttributeGroup.ModifyAttribute(attributeName, numeric, pAccumulation, pMultiplication);
            
            //Debug.Log($"Refreshed general attribute: {attributeName}, new value: {generalAttributeGroup.current[attributeName]}");
        }
        
        public void RefreshAllGeneralAttributes()
        {
            foreach (string attributeName in generalAttributeGroup.current.Keys.ToList())
            {
                RefreshGeneralAttribute(attributeName);
            }
        }

        private void ModifyGeneralAttributeFromEquipments(string attributeName)
        {
            /*EntityEquipmentModule equipmentModule = entity.equipmentModule;
            equipmentModule.GetAttributeChange(attributeName, out int numericChange,
                out float percentageChangeOfAccumulation, out float percentChangeOfMultiplication);
            currentCombatAttributes[attributeName] += numericChange;
            currentCombatAttributes[attributeName] = (int)((1 + percentageChangeOfAccumulation) * currentCombatAttributes[attributeName]);
            currentCombatAttributes[attributeName] = (int)(percentChangeOfMultiplication * currentCombatAttributes[attributeName]);*/
        }
    }
}