using System.Collections.Generic;
using UnityEngine;
using LitJson;
using System;
using System.Linq;


public class MinggeManager : GameSystemManager<MinggeManager>
{
    public int m_GanwuLV;    //感悟等级，从1开始
    public int m_GanwuExp;    //当前感悟等级经验，每级从0开始
    public int m_Lingying;    //当前灵应值
    public event Action OnMinggeInfoUpdate;

    public int equipShowPresetID;   // 显示装备时，当前的子方案ID
    public ItemModel selectFloorEquip;

    public bool waitTYOPPack;
    public event Action<int> OnOPCallbackEvent;

    public Dictionary<int, long> minggeAttrDict = new Dictionary<int, long>();



    public bool qlNotNotify;

    //配置
    public const int TotleEquip = 12; //一套装备的总数
    public int[] unlockAttrLVList;  //解锁属性所需命格物品等级列表
    public int tyItemID;    //推演物品ID
    public int qlItemID;    //祈灵物品ID
    public int[] minggeItemTypeList;    //可携带意象的卦玉类型列表
    public List<int> minggeSkillEquipPlaceList = new List<int>(); //可携带意象的卦玉类型的装备位置
    public int maxSuiteSkillCount;
    public int[] minggeSkillTypeIDList; //意向效果技能TypeID列表
    public int deitemID;    //卦玉分解的物品ID

    public override void Init()
    {
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEventOnRelogin += OnBeforePlayerDataInitializeRelogin;
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent += OnBeforePlayerDataInitialize;
        PackManager.Instance.RefreshItemEvent += RefreshItemEvent;
        DTCA814_tagMCMakeItemAnswer.MakeItemAnswerEvent += OnEquipResult;
        DTC0403_tagPlayerLoginLoadOK.playerLoginOkEvent += OnPlayerLoginOK;
        FuncPresetManager.Instance.OnFuncPresetUseDataEvent += OnFuncPresetUseDataEvent;
        GlobalTimeEvent.Instance.MSEvent += OnMSEvent;
        FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
        ParseConfig();
    }

    public override void Release()
    {
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEventOnRelogin -= OnBeforePlayerDataInitializeRelogin;
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent -= OnBeforePlayerDataInitialize;
        PackManager.Instance.RefreshItemEvent -= RefreshItemEvent;
        DTCA814_tagMCMakeItemAnswer.MakeItemAnswerEvent -= OnEquipResult;
        DTC0403_tagPlayerLoginLoadOK.playerLoginOkEvent -= OnPlayerLoginOK;
        FuncPresetManager.Instance.OnFuncPresetUseDataEvent -= OnFuncPresetUseDataEvent;
        GlobalTimeEvent.Instance.MSEvent -= OnMSEvent;
        FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
    }


    void ParseConfig()
    {
        var config = FuncConfigConfig.Get("MinggeCfg");
        unlockAttrLVList = JsonMapper.ToObject<int[]>(config.Numerical1);
        tyItemID = int.Parse(config.Numerical2);
        qlItemID = int.Parse(config.Numerical3);

        config = FuncConfigConfig.Get("MinggeTY");
        deitemID = ConfigParse.GetMultipleStr<int>(config.Numerical1)[0];
        minggeItemTypeList = JsonMapper.ToObject<int[]>(config.Numerical4);
        minggeSkillTypeIDList = JsonMapper.ToObject<int[]>(config.Numerical5);

        config = FuncConfigConfig.Get("MinggeTY2");
        fightAttrIDList = JsonMapper.ToObject<int[]>(config.Numerical1);
        deFightAttrIDList = JsonMapper.ToObject<int[]>(config.Numerical2);
        autoCostCntList = JsonMapper.ToObject<int[]>(config.Numerical3);
        autoTYCDs = JsonMapper.ToObject<float[]>(config.Numerical4);
        needOfficialRank = int.Parse(config.Numerical5);

        for (int i = 0; i < minggeItemTypeList.Length; i++)
        {
            minggeSkillEquipPlaceList.Add(MGGuayuTypeConfig.Get(minggeItemTypeList[i]).EquipPlace);
        }
        maxSuiteSkillCount = minggeSkillEquipPlaceList.Count;

    }

    private void OnBeforePlayerDataInitializeRelogin()
    {
        m_GanwuLV = 1;
        m_GanwuExp = 0;
        m_Lingying = 0;
        isStartAuto = false;
        isPauseAuto = false;
        qlNotNotify = false;
        decomposeMGList.Clear();
    }

    private void OnBeforePlayerDataInitialize()
    {
        waitTYOPPack = false;
    }

    void OnFuncStateChangeEvent(int id)
    {
        if (id == (int)FuncOpenEnum.Mingge)
        {
            InitAutoSet();
        }
    }

    void OnPlayerLoginOK()
    {
        InitAutoSet();
        UpdateRedPoint();
        redpointAuto.state = RedPointState.None;
        isMGEquipUIDecomposeToggle = true;
    }

    private void OnEquipResult(HA814_tagMCMakeItemAnswer info)
    {
        if (info.MakeType == (int)MakeType.MinggeTY)
        {
            waitTYOPPack = false;
            autoTYTime = Time.time;
            CalcEquip();
            OnOPCallbackEvent?.Invoke(0);
        }
        else if (info.MakeType == (int)MakeType.MinggeEquip)
        {
            waitTYOPPack = false;
            autoTYTime = Time.time;
            CalcEquip();
            OnOPCallbackEvent?.Invoke(1);
        }

    }

    void RefreshItemEvent(PackType type, int index, int itemID)
    {
        if (type == PackType.Item && (itemID == tyItemID || itemID == qlItemID))
        {
            UpdateRedPoint();
        }
    }

    //处理未处理的命格
    public bool CalcEquip()
    {
        var items = PackManager.Instance.GetItems(PackType.MinggeDrop);
        if (items.IsNullOrEmpty())
        {
            if (UIManager.Instance.IsOpened<MinggeEquipWin>())
            {
                UIManager.Instance.CloseWindow<MinggeEquipWin>();
            }
            return false;
        }
        Debug.Log("命格掉落背包中的物品数量：" + items.Count);

        foreach (var item in items)
        {
            if (OpenMinggeEquipWin(item))
            {
                //需要玩家处理装备
                if (!decomposeMGList.IsNullOrEmpty())
                {
                    SendDecompose(decomposeMGList.ToArray());
                    decomposeMGList.Clear();
                }

                return true;
            }
        }

        //需要玩家处理装备
        if (!decomposeMGList.IsNullOrEmpty())
        {
            SendDecompose(decomposeMGList.ToArray());
            decomposeMGList.Clear();
        }
        return false;
    }

    public void UpdateMinggeInfo(HB132_tagSCMinggeInfo netPack)
    {
        var beforeLV = m_GanwuLV;
        m_GanwuLV = netPack.GanwuLV;
        m_GanwuExp = (int)netPack.GanwuExp;
        m_Lingying = (int)netPack.Lingying;

        if (beforeLV != m_GanwuLV)
        {
            UpdateRedPoint();
            beforeLV = m_GanwuLV;
        }
        OnMinggeInfoUpdate?.Invoke();
    }

    void OnFuncPresetUseDataEvent(int type)
    {
        UpdateRedPoint();
    }


    //获取当前在使用方案的技能信息 意向技能类型ID：【物品guid..】
    public Dictionary<int, List<string>> GetMinggeSkillTypeIDDict()
    {
        var presetID = FuncPresetManager.Instance.GetFuncPresetIDByBattleType((int)BattlePreSetType.Story, (int)FuncPresetType.Mingge);
        var startIndex = (presetID - 1) * TotleEquip;//对应卦玉背包索引 = (套编号-1)*12+装备位-1

        var dict = new Dictionary<int, List<string>>();
        for (int i = 0; i < minggeSkillEquipPlaceList.Count; i++)
        {
            var equip = PackManager.Instance.GetItemByIndex(PackType.Mingge, startIndex + minggeSkillEquipPlaceList[i] - 1);
            var skillID = EquipModel.Instance.GetEquipSkillID(equip);
            if (skillID == 0) continue;
            if (dict.ContainsKey(skillID))
            {
                dict[skillID].Add(equip.guid);
            }
            else
            {
                dict[skillID] = new List<string>() { equip.guid };
            }
        }
        return dict;
    }

    //获取指定方案的技能信息 意向技能类型ID：数量
    public Dictionary<int, int> GetMinggeSkillCountDictByPresetID(int presetID)
    {
        var startIndex = (presetID - 1) * TotleEquip;//对应卦玉背包索引 = (套编号-1)*12+装备位-1

        var dict = new Dictionary<int, int>();
        for (int i = 0; i < minggeSkillEquipPlaceList.Count; i++)
        {
            var equip = PackManager.Instance.GetItemByIndex(PackType.Mingge, startIndex + minggeSkillEquipPlaceList[i] - 1);
            var skillID = EquipModel.Instance.GetEquipSkillID(equip);
            if (skillID == 0) continue;
            if (dict.ContainsKey(skillID))
            {
                dict[skillID] += 1;
            }
            else
            {
                dict[skillID] = 1;
            }
        }
        return dict;
    }

    public bool OpenMinggeEquipWin(ItemModel equip)
    {
        if (equip == null)
        {
            return false;
        }

        if (!DTC0403_tagPlayerLoginLoadOK.finishedLogin)
        {
            return false;
        }

        //自动处理： 判断分解 和战力高低 和决定是哪个方案下的装备对比
        int autoPreseetID;
        if (!AutoCalcMG(equip, out autoPreseetID))
        {
            return false;
        }


        //非自动情况下，默认当前方案
        if (autoPreseetID == 0)
        {
            equipShowPresetID = FuncPresetManager.Instance.GetFuncPresetIDByBattleType((int)BattlePreSetType.Story, (int)FuncPresetType.Mingge);
        }
        else
        {
            equipShowPresetID = autoPreseetID;
        }
        selectFloorEquip = equip;
        if (UIManager.Instance.IsOpened<MinggeWin>())
        {
            if (selectFloorEquip.config.EquipPlace == 0)
            {
                Debug.LogError($"配置错误物品 {selectFloorEquip.itemId} 装备位为0");
                return true;
            }
            if (!UIManager.Instance.IsOpened<MinggeEquipWin>())
            {
                UIManager.Instance.OpenWindow<MinggeEquipWin>();
            }
            else
            {
                //刷新界面
                var win = UIManager.Instance.GetUI<MinggeEquipWin>();
                win.RefreshUI();
            }
        }
        else
        {
            //打开界面 且外部提醒有需要处理的装备，在关闭界面的时候判断重置标识
            isPauseAuto = true;
            redpointAuto.state = RedPointState.Simple;
        }
        return true;

    }

    public int GetPackIndex(int presetID, int equipPlace)
    {
        return (presetID - 1) * TotleEquip + equipPlace - 1;//对应卦玉背包索引 = (套编号-1)*12+装备位-1
    }

    public void SendTY(int count)
    {
        // if (CalcEquip())
        // {
        //     return;
        // }
        // if (waitTYOPPack)
        // {
        //     return;
        // }

        // if (!ItemLogicUtility.CheckItemCount(PackType.Item, tyItemID, count, 2))
        // {
        //     return;
        // }
        if (waitTYOPPack)
        {
            return;
        }
        waitTYOPPack = true;

        var pack = new CB250_tagCSMinggeTuiyan();
        pack.Count = (byte)count;
        GameNetSystem.Instance.SendInfo(pack);

    }

    public void SendChangeMingge(int selectMinggePresetID, int dropIndex, bool autodec)
    {
        var pack = new CB252_tagCSMinggeEquip();
        pack.MGNum = (byte)selectMinggePresetID;
        pack.Index = (byte)dropIndex;
        pack.AutoDec = (byte)(autodec ? 1 : 0);
        GameNetSystem.Instance.SendInfo(pack);
        autoTYTime = Time.time;
        waitTYOPPack = true;
    }

    public void SendDecompose(byte[] itemIndexList)
    {
        var pack = new CB251_tagCSMinggeDecompose();
        pack.IndexList = itemIndexList;
        pack.Count = (byte)itemIndexList.Length;
        GameNetSystem.Instance.SendInfo(pack);
        autoTYTime = Time.time;
        waitTYOPPack = true;
    }


    public void RefrehMinggeAttrs()
    {
        minggeAttrDict.Clear();  //身上命格属性重置

        var minggePresetID = FuncPresetManager.Instance.GetFuncPresetIDByBattleType((int)BattlePreSetType.Story, (int)FuncPresetType.Mingge);
        var starIndex = (minggePresetID - 1) * TotleEquip;

        for (int i = starIndex; i < starIndex + TotleEquip; i++)
        {
            var equip = PackManager.Instance.GetItemByIndex(PackType.Mingge, i);
            if (equip == null)
            {
                continue;
            }

            var fightIDAttrs = EquipModel.Instance.GetEquipFightAttrs(equip);
            var fightValueAttrs = EquipModel.Instance.GetEquipFightValues(equip);
            if (fightIDAttrs != null)
            {
                for (int j = 0; j < fightIDAttrs.Count; j++)
                {
                    if (!minggeAttrDict.ContainsKey(fightIDAttrs[j]))
                    {
                        minggeAttrDict[fightIDAttrs[j]] = fightValueAttrs[j];
                    }
                    else
                    {
                        minggeAttrDict[fightIDAttrs[j]] += fightValueAttrs[j];
                    }
                }
            }
        }

    }

    public List<int> GetQLRate(int value)
    {
        var keys = MGLingyingQualityConfig.GetKeys();
        keys.Sort();

        int littleValue = 0;
        int bigValue = 0;
        for (int i = 0; i < keys.Count; i++)
        {
            var key = keys[i];
            if (value < key)
            {
                bigValue = key;
                littleValue = keys[i - 1];
                break;
            }
            else if (i == keys.Count - 1 && value >= key)
            {
                bigValue = key;
                littleValue = key;
            }
        }

        var littleRateList = MGLingyingQualityConfig.Get(littleValue).ItemColorWeightList;
        if (littleValue == bigValue)
        {
            return littleRateList.ToList();
        }
        var bigRateList = MGLingyingQualityConfig.Get(bigValue).ItemColorWeightList;

        //对比下一阶段的灵应值配置，比较同品质的权重差值与两个阶段的灵应差值求出每增加1点灵应对某个品质的权重变化值，变化值可能提升或者降低

        var rateList = new List<int>();

        for (int i = 0; i < littleRateList.Length; i++)
        {
            var littleRateValue = littleRateList[i];
            var bigRateValue = bigRateList[i];
            var diffRate = littleRateValue + (bigRateValue - littleRateValue) / (float)(bigValue - littleValue) * (value - littleValue);
            rateList.Add((int)diffRate);
        }

        return rateList;
    }


    #region 红点
    Redpoint tmpRP = new Redpoint(MainRedDot.MainAffairsRedpoint, MainRedDot.RedPoint_Mingge);
    Redpoint redpointMG = new Redpoint(MainRedDot.RedPoint_Mingge, MainRedDot.RedPoint_Mingge * 10 + 1);
    Redpoint redpointPray = new Redpoint(MainRedDot.RedPoint_Mingge, MainRedDot.RedPoint_Mingge * 10 + 2);
    Redpoint redpointPreset = new Redpoint(MainRedDot.RedPoint_Mingge, MainRedDot.RedPoint_Mingge * 10 + 3);
    public Redpoint redpointAuto = new Redpoint(MainRedDot.RedPoint_Mingge, MainRedDot.RedPoint_Mingge * 10 + 4);
    void UpdateRedPoint()
    {

        redpointMG.state = RedPointState.None;
        redpointPray.state = RedPointState.None;
        redpointPreset.state = RedPointState.None;
        if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Mingge))
        {
            return;
        }
        if (PackManager.Instance.GetItemCountByID(PackType.Item, tyItemID) > 0 && !isStartAuto)
        {
            redpointMG.state = RedPointState.Simple;
        }

        if (PackManager.Instance.GetItemCountByID(PackType.Item, qlItemID) > 0)
        {
            redpointPray.state = RedPointState.Simple;
        }
        if (FuncPresetManager.Instance.GetNeedShowRedID((int)FuncPresetType.Mingge) != 0)
        {
            redpointPreset.state = RedPointState.Simple;
        }
    }

    #endregion


    #region 自动设置

    public int[] fightAttrIDList;
    public int[] deFightAttrIDList;
    public int[] autoCostCntList;
    public float[] autoTYCDs;    //秒
    public float autoTYTime;
    public int needOfficialRank;

    public bool isMGEquipUIDecomposeToggle; //装备对比界面 是否勾选了分解

    //公共部分
    public bool autoCostToggle
    {
        get
        {
            return LocalSave.GetBool($"MGCost_{PlayerDatas.Instance.baseData.PlayerID}", false);
        }
        set
        {
            LocalSave.SetBool($"MGCost_{PlayerDatas.Instance.baseData.PlayerID}", value);
        }
    }

    //勾选后展示用的
    public int autoCostCount
    {
        get
        {
            return LocalSave.GetInt($"MGCostCnt_{PlayerDatas.Instance.baseData.PlayerID}", 1);
        }
        set
        {
            LocalSave.SetInt($"MGCostCnt_{PlayerDatas.Instance.baseData.PlayerID}", value);
        }
    }

    //实际消耗用的 不勾选的时候默认返回1
    public int useAutoCostCnt
    {
        get
        {
            if (!autoCostToggle)
            {
                return 1;
            }
            return autoCostCount;
        }

    }
    public bool autoSpeedUP
    {
        get
        {
            return LocalSave.GetBool($"MGSpeedUP_{PlayerDatas.Instance.baseData.PlayerID}", false);
        }
        set
        {
            LocalSave.SetBool($"MGSpeedUP_{PlayerDatas.Instance.baseData.PlayerID}", value);
        }
    }


    public event Action ChangeAutoEvent;

    bool m_IsStartAuto;
    //是否开启自动
    public bool isStartAuto
    {
        get
        {
            return m_IsStartAuto;
        }
        private set
        {
            m_IsStartAuto = value;
            isPauseAuto = false;
            decomposeMGList.Clear();
            UpdateRedPoint();
            ChangeAutoEvent?.Invoke();
        }
    }
    public bool isPauseAuto;    //开启的情况下，因为某些原因暂停自动


    //每套方案各自的信息
    public List<MinggeAutoSet> autoSetList = new List<MinggeAutoSet>();

    public void InitAutoSet()
    {
        autoSetList.Clear();
        if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Mingge))
        {
            return;
        }
        var maxCnt = PresetUnlockConfig.GetFuncPresetMaxCount((int)FuncPresetType.Mingge);
        for (int i = 1; i <= maxCnt; i++)
        {
            var autoSet = new MinggeAutoSet();
            autoSet.presetID = i;
            autoSetList.Add(autoSet);
        }
    }

    public MinggeAutoSet GetMGAutoSet(int presetID)
    {
        for (int i = 0; i < autoSetList.Count; i++)
        {
            if (autoSetList[i].presetID == presetID)
            {
                return autoSetList[i];
            }
        }
        return null;
    }

    //检查至少要有一个启动中
    public bool CanChangeStartToFalse(int presetID)
    {
        for (int i = 0; i < autoSetList.Count; i++)
        {
            if (autoSetList[i].presetID != presetID && autoSetList[i].startToggle)
            {
                return true;
            }
        }
        return false;
    }

    public void StartAuto(bool isStart)
    {
        if (isStart)
        {

            bool canStart = false;
            for (int i = 0; i < autoSetList.Count; i++)
            {
                if (autoSetList[i].startToggle)
                {
                    canStart = true;
                }
            }

            if (!canStart)
            {
                SysNotifyMgr.Instance.ShowTip("MinggeAuto2");
                isStartAuto = false;
                return;
            }


            if (!ItemLogicUtility.CheckItemCount(PackType.Item, tyItemID, useAutoCostCnt, 2))
            {
                isStartAuto = false;
                TimingGiftManager.Instance.TryAddWhenInsufficient(6, PackType.Item, tyItemID, useAutoCostCnt);
                return;
            }
            UIManager.Instance.CloseWindow<MinggeAutoSetWin>();
            TimingGiftManager.Instance.TryAddWhenExactConsumption(6, PackType.Item, tyItemID, useAutoCostCnt);

        }

        isStartAuto = isStart;
        if (isStartAuto)
        {
            //先处理装备一次，后续通过物品包自动处理
            CalcEquip();
        }
        else
        {
            SysNotifyMgr.Instance.ShowTip("MinggeAuto1");
        }
    }

    //自动处理装备，返回成功代表需要手动处理装备，其他情况一律返回false如分解 或防范
    bool AutoCalcMG(ItemModel mgEquip, out int autoPreseetID)
    {
        autoPreseetID = 0;
        if (mgEquip == null)
        {
            return false;
        }

        if (!isStartAuto)
            return true;
        if (!isMGEquipUIDecomposeToggle && UIManager.Instance.IsOpened<MinggeEquipWin>())
        {
            //玩家没有勾选装备对比界面的分解， 那么自动不可处理分解
            return true;
        }

        //优先判断当前方案命格
        var curPresetID = FuncPresetManager.Instance.GetFuncPresetID((int)FuncPresetType.Mingge);
        var autoSet = GetMGAutoSet(curPresetID);


        if (!CanDecomposeMG(mgEquip, autoSet))
        {
            autoPreseetID = curPresetID;
            return true;
        }
        //判断其他方案
        for (int i = 0; i < autoSetList.Count; i++)
        {
            if (autoSetList[i].presetID == curPresetID)
            {
                continue;
            }
            if (!CanDecomposeMG(mgEquip, autoSetList[i]))
            {
                autoPreseetID = autoSetList[i].presetID;
                return true;
            }
        }

        // SendDecompose(new byte[] { (byte)mgEquip.gridIndex });
        AddDecomposeMG((byte)mgEquip.gridIndex);
        return false;
    }

    List<byte> decomposeMGList = new List<byte>();
    void AddDecomposeMG(byte index)
    {
        if (decomposeMGList.Contains(index))
        {
            return;
        }
        decomposeMGList.Add(index);
    }


    //单方案判断，未开启的也当作可分解，外层多套判断有一套需要就是需要穿戴
    bool CanDecomposeMG(ItemModel mgEquip, MinggeAutoSet autoSet)
    {
        if (!autoSet.startToggle)
        {
            return true;
        }
        if (mgEquip.config.ItemColor < autoSet.quanlity)
        {
            //品质不满足
            return true;
        }
        if (!autoSet.fightPowerToggle && !autoSet.fightAttrToggle && !autoSet.skillToggle)
        {
            //都不勾选
            return false;
        }


        //先判断技能，再判断属性 最后战力（比较消耗）

        //技能勾选的情况
        if (autoSet.skillToggle && !autoSet.fightPowerToggle && !autoSet.fightAttrToggle)
        {
            return !IsSkillOK(mgEquip, autoSet);
        }

        if (autoSet.skillToggle && autoSet.fightAttrToggle && !autoSet.fightPowerToggle)
        {
            if (autoSet.andOrSkillToggle == 1)
            {
                return !(IsSkillOK(mgEquip, autoSet) && IsFightAttrOK(mgEquip, autoSet));
            }
            else
            {
                return !(IsSkillOK(mgEquip, autoSet) || IsFightAttrOK(mgEquip, autoSet));
            }
        }

        if (autoSet.skillToggle && autoSet.fightPowerToggle && !autoSet.fightAttrToggle)
        {
            if (autoSet.andOrSkillToggle == 1)
            {
                return !(IsSkillOK(mgEquip, autoSet) && IsFightPowerOK(mgEquip, autoSet));
            }
            else
            {
                return !(IsSkillOK(mgEquip, autoSet) || IsFightPowerOK(mgEquip, autoSet));
            }
        }

        if (autoSet.skillToggle && autoSet.fightPowerToggle && autoSet.fightAttrToggle)
        {
            if (autoSet.andOrSkillToggle == 1 && autoSet.andOrFPToggle == 1)
            {
                return !(IsSkillOK(mgEquip, autoSet) && IsFightAttrOK(mgEquip, autoSet) && IsFightPowerOK(mgEquip, autoSet));
            }
            else if (autoSet.andOrSkillToggle == 1 && autoSet.andOrFPToggle == 2)
            {
                return !((IsSkillOK(mgEquip, autoSet) && IsFightAttrOK(mgEquip, autoSet)) || IsFightPowerOK(mgEquip, autoSet));
            }
            else if (autoSet.andOrSkillToggle == 2 && autoSet.andOrFPToggle == 1)
            {
                return !((IsFightAttrOK(mgEquip, autoSet) && IsFightPowerOK(mgEquip, autoSet)) || IsSkillOK(mgEquip, autoSet));
            }
            else
            {
                return !(IsSkillOK(mgEquip, autoSet) || IsFightAttrOK(mgEquip, autoSet) || IsFightPowerOK(mgEquip, autoSet));
            }
        }

        //属性勾选的情况
        if (autoSet.fightAttrToggle && !autoSet.fightPowerToggle)
        {
            return !IsFightAttrOK(mgEquip, autoSet);
        }
        if (autoSet.fightAttrToggle && autoSet.fightPowerToggle)
        {
            if (autoSet.andOrFPToggle == 1)
            {
                return !(IsFightAttrOK(mgEquip, autoSet) && IsFightPowerOK(mgEquip, autoSet));
            }
            else
            {
                return !(IsFightAttrOK(mgEquip, autoSet) || IsFightPowerOK(mgEquip, autoSet));
            }
        }

        //战力勾选的情况
        if (autoSet.fightPowerToggle)
        {
            return !IsFightPowerOK(mgEquip, autoSet);
        }

        return false;
    }

    //技能是否满足条件
    bool IsSkillOK(ItemModel mgEquip, MinggeAutoSet autoSet)
    {
        var skillID = EquipModel.Instance.GetEquipSkillID(mgEquip);
        if (skillID == 0)
        {
            return false;
        }
        if (autoSet.skillID == 0)
        {
            //任意
            return true;
        }
        if (skillID != autoSet.skillID)
        {
            return false;
        }

        return true;
    }

    //属性是否满足条件
    bool IsFightAttrOK(ItemModel mgEquip, MinggeAutoSet autoSet)
    {
        var fightAttrs = EquipModel.Instance.GetEquipFightAttrs(mgEquip);

        // 如果指定了属性，则检查装备是否包含该属性
        bool deFightAttrOK = autoSet.deFightAttrID == 0 || fightAttrs.Contains(autoSet.deFightAttrID);
        bool fightAttrOK = autoSet.fightAttrID == 0 || fightAttrs.Contains(autoSet.fightAttrID);

        return deFightAttrOK && fightAttrOK;
    }

    bool IsFightPowerOK(ItemModel mgEquip, MinggeAutoSet autoSet)
    {
        long showFightPower = FightPowerManager.Instance.GetFightPowerMinggeChange(mgEquip, autoSet.presetID);
        if (showFightPower > 0)
        {
            return true;
        }
        return false;
    }


    public void AutoTY()
    {
        //先处理装备，再推演
        // 每一套方案都要综合判断
        // if (CalcEquip())
        // {
        //     return;
        // }
        if (UIManager.Instance.IsOpened<MinggeEquipWin>())
        {
            return;
        }

        if (!PackManager.Instance.GetItems(PackType.MinggeDrop).IsNullOrEmpty())
        {
            return;
        }

        if (!ItemLogicUtility.CheckItemCount(PackType.Item, tyItemID, useAutoCostCnt, 1))
        {
            isStartAuto = false;
            SysNotifyMgr.Instance.ShowTip("MinggeAuto1");
            TimingGiftManager.Instance.TryAddWhenInsufficient(6, PackType.Item, tyItemID, useAutoCostCnt);
            return;
        }

        TimingGiftManager.Instance.TryAddWhenExactConsumption(6, PackType.Item, tyItemID, useAutoCostCnt);

        autoTYTime = Time.time;
        SendTY(useAutoCostCnt);


    }

    void OnMSEvent()
    {
        if (isPauseAuto)
        {
            return;
        }
        if (!isStartAuto)
        {
            return;
        }
        if (Time.time - autoTYTime < autoTYCDs[autoSpeedUP ? 1 : 0])
        {
            if (!waitTYOPPack)
            {
                if (UIManager.Instance.IsOpened<MinggeWin>())
                {
                    //显示特效
                    var ui = UIManager.Instance.GetUI<MinggeWin>();
                    if (!ui.tyEffect.isPlaying)
                    {
                        ui.tyEffect.onComplete = null;
                        ui.tyEffect.Play();
                        if (autoSpeedUP)
                        {
                            ui.tyEffect.SetSpeed(autoTYCDs[0] / autoTYCDs[1]);
                        }
                        else
                        {
                            ui.tyEffect.SetSpeed(1);
                        }
                    }
                }

            }
            return;
        }

        AutoTY();
    }

    #endregion
}

public class MinggeAutoSet
{
    public int presetID;
    public bool startToggle
    {
        get
        {
            return LocalSave.GetBool($"MGStart{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", false);
        }
        set
        {
            LocalSave.SetBool($"MGStart{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
        }
    }
    public int quanlity
    {
        get
        {
            return LocalSave.GetInt($"MGQuanlity{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", 1);
        }
        set
        {
            LocalSave.SetInt($"MGQuanlity{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
        }
    }
    public bool fightPowerToggle
    {
        get
        {
            return LocalSave.GetBool($"MGFightPower{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", false);
        }
        set
        {
            LocalSave.SetBool($"MGFightPower{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
        }
    }
    //0 都不勾选 1同时 2 或者
    public int andOrFPToggle
    {
        get
        {
            return LocalSave.GetInt($"MGAndOrFP{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", 0);
        }
        set
        {
            LocalSave.SetInt($"MGAndOrFP{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
        }
    }

    public bool fightAttrToggle
    {
        get
        {
            return LocalSave.GetBool($"MGFightAttr{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", false);
        }
        set
        {
            LocalSave.SetBool($"MGFightAttr{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
        }
    }
    public int fightAttrID
    {
        get
        {
            return LocalSave.GetInt($"MGFightAttrID{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", 0);
        }
        set
        {
            LocalSave.SetInt($"MGFightAttrID{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
        }
    }
    public int deFightAttrID
    {
        get
        {
            return LocalSave.GetInt($"MGDeFightAttrID{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", 0);
        }
        set
        {
            LocalSave.SetInt($"MGDeFightAttrID{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
        }
    }
    public bool skillToggle
    {
        get
        {
            return LocalSave.GetBool($"MGSkill{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", false);
        }
        set
        {
            LocalSave.SetBool($"MGSkill{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
        }
    }
    public int skillID
    {
        get
        {
            return LocalSave.GetInt($"MGSkillID{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", 0);
        }
        set
        {
            LocalSave.SetInt($"MGSkillID{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
        }
    }
    //0 都不勾选 1同时 2 或者
    public int andOrSkillToggle
    {
        get
        {
            return LocalSave.GetInt($"MGAndOrSkill{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", 0);
        }
        set
        {
            LocalSave.SetInt($"MGAndOrSkill{presetID}_{PlayerDatas.Instance.baseData.PlayerID}", value);
        }
    }



}