using System.Collections.Generic;
using Excel2Json;
using Fort23.Mono;
using Fort23.UTool;
using GameLogic.Bag;
using GameLogic.Player;
using UnityEditor;
using UnityEngine;

namespace GameLogic.Equipment
{

    public class EqAddAttribute
    {
        public long atk;
        public long def;
        public long hp;

        // public void AddAtk(long atk)
        // {
        //     this.atk += atk;
        // }
        //
        // public void AddDef(long def)
        // {
        //     this.def += def;
        // }
        //
        // public void AddHp(long hp)
        // {
        //     this.hp += hp;
        // }
    } 
    
    public class EquipmentController
    {
        /// <summary>
        /// 所有的装备 按 这个逻辑存储 {职业, {部位, 装备列表}}
        /// 存在意义：一键换装的时候，可以快速找到目标装备
        /// 
        /// </summary>
        public Dictionary<int, Dictionary<int ,List<ItemInfo>>> allZyEqDic = new Dictionary<int, Dictionary<int ,List<ItemInfo>>>();

        /// <summary>
        /// 已穿戴的装备
        /// </summary>
        public Dictionary<int, List<ItemInfo>> equipZyEqDic = new Dictionary<int, List<ItemInfo>>();
        
        /// <summary>
        /// 职业装备提供的属性
        /// </summary>
        public Dictionary<int, EqAddAttribute> zyEqAddAttributeDic = new Dictionary<int, EqAddAttribute>();
        
        // private long curGUID;


        public EquipmentController()
        {
            zyEqAddAttributeDic.Add(1, new EqAddAttribute());
            zyEqAddAttributeDic.Add(2, new EqAddAttribute());
            zyEqAddAttributeDic.Add(3, new EqAddAttribute());
            zyEqAddAttributeDic.Add(4, new EqAddAttribute());
            
            equipZyEqDic.Add(1, new List<ItemInfo>());
            equipZyEqDic.Add(2, new List<ItemInfo>());
            equipZyEqDic.Add(3, new List<ItemInfo>());
            equipZyEqDic.Add(4, new List<ItemInfo>());
        }
        

        public void Init(ItemInfo itemInfo)
        {
            AddEquipment(itemInfo);
            if (itemInfo.eqInfo != null && itemInfo.eqInfo.isWear)
            {
                AddToCurEquip(itemInfo, true);
            }
        }

        private void CalZyEqAddAttribute()
        {
            foreach (KeyValuePair<int,List<ItemInfo>> keyValuePair in equipZyEqDic)
            {
                int zy = keyValuePair.Key;
                ResetZyEqAddAttribute(zy);
                foreach (ItemInfo eqItem in keyValuePair.Value)
                {
                    zyEqAddAttributeDic[zy].atk += eqItem.eqInfo.Attack;
                    zyEqAddAttributeDic[zy].def += eqItem.eqInfo.Defense;
                    zyEqAddAttributeDic[zy].hp += eqItem.eqInfo.Hp;
                }
            }
        }

        private void ResetZyEqAddAttribute(int zy)
        {
            zyEqAddAttributeDic[zy].atk = 0;
            zyEqAddAttributeDic[zy].def = 0;
            zyEqAddAttributeDic[zy].hp = 0;
        }

        /// <summary>
        /// 通过品质获取装备的额外参数，装备属性会叠加这个值
        /// </summary>
        /// <param name="quality"></param>
        /// <returns></returns>
        public float GetEquipmentRarityAttributeFactor(int quality)
        {
            int[] factors = PlayerManager.Instance.gameConstantConfig.equipmentRarityAttributeFactor;
            // LogTool.Log(quality);
            return factors[quality - 1] / (float)100;
        }

        
        public ItemInfo BuildEquipment(int equipModelDropID, int qualityDropID, int lvDropID)
        {
            ItemInfo info = null;
            List<ItemInfo> equipModelDropItems = DropManager.Instance.DropItem(equipModelDropID);
            if (equipModelDropItems == null || equipModelDropItems.Count == 0)
            {
                return info;
            }
            
            ItemInfo equipModelInfo = equipModelDropItems[0];
            
            List<ItemInfo> qualityDropItems = DropManager.Instance.DropItem(qualityDropID);
            List<ItemInfo> lvDropItems = DropManager.Instance.DropItem(lvDropID);

            info = equipModelInfo;

            info.eqInfo = new EquipmentInfo();
            // info.eqInfo.InitEquipment(info.config,
            //     lvDropItems[0].dropItemConfig.itemID[0], 
            //     qualityDropItems[0].dropItemConfig.itemID[0]);
            info.eqInfo.InitEquipment(equipModelInfo, lvDropItems[0], qualityDropItems[0]);
            
            return info;
        }
        public ItemInfo BuildEquipmentForItemId(int itemId, int qualityDropID, int lvDropID)
        {
            ItemInfo info = null;



            ItemInfo equipModelInfo = new ItemInfo(itemId, 1);
            
            List<ItemInfo> qualityDropItems = DropManager.Instance.DropItem(qualityDropID);
            List<ItemInfo> lvDropItems = DropManager.Instance.DropItem(lvDropID);

            info = equipModelInfo;

            info.eqInfo = new EquipmentInfo();
            // info.eqInfo.InitEquipment(info.config,
            //     lvDropItems[0].dropItemConfig.itemID[0], 
            //     qualityDropItems[0].dropItemConfig.itemID[0]);
            info.eqInfo.InitEquipment(equipModelInfo, lvDropItems[0], qualityDropItems[0]);
            
            return info;
        }


        public bool atLeastOneBetterEq = false;
        /// <summary>
        /// 是否有更好的装备
        /// </summary>
        /// <param name="isReCal">是否重新计算最好的装备</param>
        /// <returns></returns>
        public bool IsBetterEqs(bool isReCal = true)
        {
            if (isReCal)
            {
                UpdateAllBestEqs();
            }

            atLeastOneBetterEq = false;

            int count = 0;
            
            foreach (KeyValuePair<int,Dictionary<int,ItemInfo>> keyValuePair in allBestEqDic)
            {
                int zy = keyValuePair.Key;
                Dictionary<int, ItemInfo> bwDic = keyValuePair.Value;
                count += bwDic.Count;
                // if (bwDic.Count > 0)
                // {
                //     // return true;
                //     count++;
                // }
            }

            if (count >= 1)
            {
                atLeastOneBetterEq = true;
            }
            
            //有2个以上的职业，有更好准备是再显示最外层的小红点.
            if (count > 3)
            {
                return true;
            }

            return false;
        }

        /// <summary>
        /// 具体职业是否有更好装备
        /// </summary>
        /// <param name="zy"></param>
        /// <returns></returns>
        public bool IsBetterEqs4OneZy(int zy, bool isReCal = false)
        {
            if (isReCal)
            {
                UpdateAllBestEqs();
            }
            if (allBestEqDic != null)
            {
                if (allBestEqDic.TryGetValue(zy, out var bwDic))
                {
                    if (bwDic.Count > 0)
                    {
                        return true;
                    }
                } 
                
            }

            return false;
        }


        public Dictionary<int, Dictionary<int, ItemInfo>> allBestEqDic;
        /// <summary>
        /// 计算所有职业最好的装备，用于小红点
        /// allBestEqDic里面存的，就是所有职业，最好的装备
        /// </summary>
        /// <returns></returns>
        public Dictionary<int, Dictionary<int, ItemInfo>> UpdateAllBestEqs()
        {
            allBestEqDic = new Dictionary<int, Dictionary<int, ItemInfo>>();

            allBestEqDic.Add(1, GetZyBestEqs(1));
            allBestEqDic.Add(2, GetZyBestEqs(2));
            allBestEqDic.Add(3, GetZyBestEqs(3));
            allBestEqDic.Add(4, GetZyBestEqs(4));
            return allBestEqDic;
        }

        public Dictionary<int, ItemInfo> GetZyBestEqs(int zy)
        {
            Dictionary<int, ItemInfo> bestEqDic = new Dictionary<int, ItemInfo>();
            bool changed = false;
            //拿到这个职业的所有部位的装备，bwDic就是一个按部位划分的字典key=部位，value=这个部位下的所有装备
            if (allZyEqDic.TryGetValue(zy, out var bwDic))
            {
                foreach (KeyValuePair<int, List<ItemInfo>> keyValuePair in bwDic)
                {
                    ItemInfo bestBwEq = null;
                    foreach (ItemInfo bwItem in keyValuePair.Value)
                    {
                        // if (bwItem.eqInfo.isWear)
                        // {
                        //     continue;
                        // }
                        // bwItem.eqInfo.isEquip = false;
                        if (bestBwEq == null)
                        {
                            bestBwEq = bwItem;
                            continue;
                        }

                        if (bwItem.eqInfo.Attack > bestBwEq.eqInfo.Attack ||
                            bwItem.eqInfo.Defense > bestBwEq.eqInfo.Defense ||
                            bwItem.eqInfo.Hp > bestBwEq.eqInfo.Hp)
                        {
                            bestBwEq = bwItem;
                        }
                    }

                    if (bestBwEq != null)
                    {
                        if(!bestBwEq.eqInfo.isWear)
                            bestEqDic.Add(keyValuePair.Key, bestBwEq);
                    }
                }
            }
            
            return bestEqDic;
        }

        /// <summary>
        /// 一键穿职业装备
        /// 把对应职业，对应部位的，最好的装备找出来
        /// </summary>
        /// <param name="zy"></param>
        /// <returns>true = 有装备变动 </returns>
        public bool QuickEquip(int zy)
        {
            bool changed = false;
            //拿到这个职业的所有部位的装备，bwDic就是一个按部位划分的字典key=部位，value=这个部位下的所有装备
            if (allZyEqDic.TryGetValue(zy, out var bwDic))
            {
                foreach (KeyValuePair<int, List<ItemInfo>> keyValuePair in bwDic)
                {
                    ItemInfo bestBwEq = null;
                    foreach (ItemInfo bwItem in keyValuePair.Value)
                    {
                        // if (bwItem.eqInfo.isWear)
                        // {
                        //     continue;
                        // }
                        // bwItem.eqInfo.isEquip = false;
                        if (bestBwEq == null)
                        {
                            bestBwEq = bwItem;
                            continue;
                        }

                        if (bwItem.eqInfo.Attack > bestBwEq.eqInfo.Attack ||
                            bwItem.eqInfo.Defense > bestBwEq.eqInfo.Defense ||
                            bwItem.eqInfo.Hp > bestBwEq.eqInfo.Hp)
                        {
                            bestBwEq = bwItem;
                        }
                    }

                    if (bestBwEq != null)
                    {
                        bool b = AddToCurEquip(bestBwEq);

                        if (!changed)
                        {
                            changed = b;     
                        }

                    }
                }
            }
            
            return changed;
        }


        /// <summary>
        /// 把装备加到：当前已经穿的装备列表中管理
        /// </summary>
        /// <param name="bestEqItem"></param>
        /// <param name="isInit">true 表示是初始化，初始化时，不支持保存数据的逻辑</param>
        /// <returns></returns>
        public bool AddToCurEquip(ItemInfo bestEqItem, bool isInit = false)
        {
            int zy = bestEqItem.eqInfo.basicEquipConfig.profession;
            
            bool isAdd = true;
            
            if (equipZyEqDic.TryGetValue(zy, out var eqList))
            {
                // 从后往前遍历，这样删除元素不会影响索引
                for (int i = eqList.Count - 1; i >= 0; i--)
                {
                    ItemInfo itemInfo = eqList[i];
                    if (itemInfo.eqInfo.basicEquipConfig.Type == bestEqItem.eqInfo.basicEquipConfig.Type)
                    {
                        //已经在已装备列表里面了，就不加了
                        if (itemInfo.Equals(bestEqItem))
                        {
                            isAdd = false;
                        }
                        else
                        {
                            //老装备脱下来
                            EquipLogic(false, itemInfo);
                            //从已装备的列表处，移除
                            eqList.RemoveAt(i);
                            if (!isInit)
                            {
                                AccountFileInfo.Instance.SaveItemData(itemInfo);
                            }
                        }
                        break;
                    }
                }

                if (isAdd)
                {
                    EquipLogic(true, bestEqItem);
                    eqList.Add(bestEqItem);
                }
            }
            else
            {
                EquipLogic(true, bestEqItem);
                
                eqList = new List<ItemInfo>();
                eqList.Add(bestEqItem);
                equipZyEqDic.Add(zy, eqList);
            }

            //有装备变更时，计算一下装备提供的属性
            if (isAdd)
            {
                CalZyEqAddAttribute();
                if (!isInit)
                {
                    AccountFileInfo.Instance.SaveItemData(bestEqItem);
                }
            }

            return isAdd;
        }

        /// <summary>
        /// 穿/脱 装备的逻辑
        /// </summary>
        /// <param name="equip">穿or脱</param>
        /// <param name="eqItemInfo">装备item</param>
        public void EquipLogic(bool equip, ItemInfo eqItemInfo)
        {
            eqItemInfo.eqInfo.isWear = equip;
            if (equip)
            {
                eqItemInfo.count.Value--;
            }
            else
            {
                eqItemInfo.count.Value++;
            }
        }
        
        /// <summary>
        /// 这里2次管理装备item的目的是为了：后续穿脱装备时，遍历效率更高
        /// </summary>
        /// <param name="eqItemInfo"></param>
        public void AddEquipment(ItemInfo eqItemInfo)
        {
            if (!eqItemInfo.IsEquipItem())
            {
                return;
            }
            
            // allEqDic.Add(eqItemInfo.guid, eqItemInfo);
            
            int zy = eqItemInfo.eqInfo.basicEquipConfig.profession;
            int bw = eqItemInfo.eqInfo.basicEquipConfig.Type;
            if (allZyEqDic.TryGetValue(zy, out var bwDic))
            {
                if (bwDic.TryGetValue(bw, out var eqBwList))
                {
                    bool isAdd = true;
                    foreach (ItemInfo itemInfo in eqBwList)
                    {
                        if (itemInfo.guid == eqItemInfo.guid)
                        {
                            isAdd = false;
                            // LogTool.Warning("已经有这个装备，不再重复添加："+ eqItemInfo.guid);
                            break;
                        }
                    }

                    if (isAdd)
                    {
                        eqBwList.Add(eqItemInfo);
                    }
                    
                }
                else
                {
                    eqBwList = new List<ItemInfo>();
                    eqBwList.Add(eqItemInfo);
                    bwDic.Add(bw, eqBwList);
                }
            }
            else
            {
                bwDic = new Dictionary<int, List<ItemInfo>>();
                List<ItemInfo> eqBwList = new List<ItemInfo>();
                eqBwList.Add(eqItemInfo);
                bwDic.Add(bw, eqBwList);
                allZyEqDic.Add(zy, bwDic);
            }
        }

        // public void RemoveEquipment(ItemInfo eqItemInfo)
        // {
        //     if (eqItemInfo.eqInfo == null)
        //     {
        //         return;
        //     }
        //
        //     int zy = eqItemInfo.eqInfo.basicEquipConfig.profession;
        //     int bw = eqItemInfo.eqInfo.basicEquipConfig.Type;
        //
        //     if (allZyEqDic.TryGetValue(zy, out var bwDic))
        //     {
        //         if (bwDic.TryGetValue(bw, out var eqList))
        //         {
        //             eqList.Remove(eqItemInfo);
        //         }
        //         else
        //         {
        //             LogTool.Error("移除一个在背包不存在的(bw)，装备: guid=" + eqItemInfo.guid + "   职业=" + zy);
        //         }
        //     }
        //     else
        //     {
        //         LogTool.Error("移除一个在背包不存在的(zy)，装备: guid=" + eqItemInfo.guid + "   职业=" + zy);
        //     }
        //     
        //     // if (zyEqDic.ContainsKey(pro) && zyEqDic[pro].Contains(eqItemInfo))
        //     // {
        //     //     zyEqDic[pro].Remove(eqItemInfo);
        //     // }
        //     // else
        //     // {
        //     //     LogTool.Error("移除一个在背包不存在的，装备: guid=" + eqItemInfo.guid + "   职业=" + pro);
        //     // }
        // }
    }
}