/**********************************************
//作者:#何健#
//日期:#2016.10.17#
//简述:#物品管理类，
        主要处理背包物品网络消息及物品管理#
*********************************************/
using MSG_backpack;
using MSG_SoulArmor;
using System;
using System.Collections;
using System.Collections.Generic;
using Thousandto.Cfg.Data;
using Thousandto.Code.Center;
using Thousandto.Code.Global;
using Thousandto.Core.Base;
using Thousandto.Plugins.Common;
using UnityEngine;
using CoroutinePool = UnityEngine.Gonbest.MagicCube.CoroutinePool;

namespace Thousandto.Code.Logic
{
    public class ItemContianerSystem : BaseSystem
    {
        #region 数据成员
        private Dictionary<int, ItemContianerModel> _itemContianerDic;
        private float[] _sortBackPackTime;  //背包整理时间
        private Dictionary<int, long> _enconomy;          //玩家的货币包括经验  
        public float _curCountTime;      //当前计时时间  
        public bool _isBeginCountDown;  //是否倒计时 
        public bool IsAlertAutoUse;     //自动使用物品提示
        private Dictionary<int, ItemMsgCondition> _itemMsgConDic;
        
        public ulong CurSelectItemDbid
        {
            get;set;
        }
        #endregion

        #region 初始化及帧更新
        public void Initialize()
        {
            //设置更新频率
            _updateFrameRate = 5;
            _sortBackPackTime = new float[(int)ContainerType.ITEM_LOCATION_COUNT];
            _itemContianerDic = new Dictionary<int, ItemContianerModel>();
            _enconomy = new Dictionary<int, long>();
            CurSelectItemDbid = 0;
            IsAlertAutoUse = false;
        }

        public void Uninitialize()
        {
            if (_itemMsgConDic != null)
                _itemMsgConDic.Clear();
            _itemContianerDic.Clear();
            _enconomy.Clear();
            for (int idx = 0; idx < _sortBackPackTime.Length; ++idx)
            {
                _sortBackPackTime[idx] = 0;
            }
        }

        /// <summary>
        /// 更新物品容器更新时间
        /// </summary>
        protected override bool OnUpdate(float deltaTime)
        {
            if (_isBeginCountDown == true && _curCountTime > 0)
            {
                _curCountTime -= deltaTime;
            }
            if (null == _itemContianerDic)
            {
                return false;
            }

            var e = _itemContianerDic.GetEnumerator();
            try
            {
                while (e.MoveNext())
                {
                    e.Current.Value.UseTime += deltaTime;
                }
            }
            finally
            {
                e.Dispose();
            }

            if (null != _sortBackPackTime)
            {
                for (int idx = 0; idx < _sortBackPackTime.Length; ++idx)
                {
                    if (_sortBackPackTime[idx] > 0)
                    {
                        _sortBackPackTime[idx] -= deltaTime;
                    }
                }
            }
            return true;
        }
        #endregion

        #region 公共接口
        public void AddItemMsgCondition(LogicEventDefine itemMsg, int[] items, int id)
        {
            AddItemMsgCondition((int)itemMsg, items, id);
        }
        public void AddItemMsgCondition(int itemMsg, int[] items, int id)
        {
            var itemCon = new ItemMsgCondition(itemMsg, items);
            if (_itemMsgConDic != null && _itemMsgConDic.ContainsKey(id))
                _itemMsgConDic.Remove(id);
            if (_itemMsgConDic == null)
                _itemMsgConDic = new Dictionary<int, ItemMsgCondition>();
            _itemMsgConDic.Add(id, itemCon);
        }

        public void ClearItemMsgCondition(int id)
        {
            if (_itemMsgConDic != null && _itemMsgConDic.ContainsKey(id))
                _itemMsgConDic.Remove(id);
            GameCenter.MainFunctionSystem.SetAlertFlag(id, false);
        }

        private void CheckItemChangeMsg(int id)
        {
            if (_itemMsgConDic == null)
                return;
            var e = _itemMsgConDic.GetEnumerator();
            try
            {
                while (e.MoveNext())
                {
                    e.Current.Value.Check(id);
                }
            }
            finally { e.Dispose(); }
        }

        /// <summary>
        /// 获取背包剩余格子数
        /// </summary>
        /// <returns></returns>
        public int GetRemainCount()
        {
            ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_BAG);
            var ret = 0;
            if (null != bpModel)
            {
                ret = bpModel.OpenedCount - bpModel.ItemsOfUID.Values.Count;
            }
            return ret;
        }
        //获取背包整理所需时间
        public float GetBagSortTime(ContainerType type)
        {
            float ret = default(float);
            if (type >= ContainerType.ITEM_LOCATION_COUNT)
            {
                //TODO 写日志
                return ret;
            }
            return _sortBackPackTime[(int)type];
        }

        //设置背包整理时间
        public void SetBagSortTime(ContainerType type, float time)
        {
            if (type >= ContainerType.ITEM_LOCATION_COUNT)
            {
                //TODO 写日志
                return;
            }
            _sortBackPackTime[(int)type] = time;
        }

        //根据容器类型获取容器信息
        public ItemContianerModel GetBackpackModelByType(ContainerType type)
        {
            ItemContianerModel bpModel = null;
            if (_itemContianerDic != null)
                _itemContianerDic.TryGetValue((int)type, out bpModel);
            return bpModel;
        }

        /// <summary>
        /// 设置容器
        /// </summary>
        /// <param name="type"></param>
        /// <param name="model"></param>
        public void SetBackpackModelByType(ContainerType type, ItemContianerModel model)
        {
            if (null != model && ContainerType.ITEM_LOCATION_COUNT > type)
            {
                _itemContianerDic.Add((int)type, model);
            }
        }

        //更新物品
        public int UpdateItemFromContainer(ContainerType type, ItemInfo item, bool isNew = false, int resonCode = 0, bool pushEvent = true)
        {
            if (item.cdTime > 0)
            {
                item.cdTime = item.cdTime / 1000;
            }
            int retIndex = -1;
            ItemContianerModel bpModel = GetBackpackModelByType(type);
            if (null != bpModel && null != item)
            {
                ItemBase itemBase = null;
                itemBase = new ItemBase(item);
                switch (itemBase.Type)
                {
                    case ItemType.Equip:
                        itemBase = new Equipment(item);
                        break;
                    case ItemType.ImmortalEquip:
                        itemBase = new ImmortalEquip(item);
                        if (type == ContainerType.ITEM_LOCATION_BACKEQUIP)
                            itemBase.Index = itemBase.Part;
                        break;
                    default:
                        itemBase = new ItemModel(item);
                        break;
                }
                itemBase.IsNew = isNew;

                if (isNew && type == ContainerType.ITEM_LOCATION_BAG)
                {
                    //引导检测
                    GameCenter.GuideSystem.Check(GuideTriggerType.GetItem, item.itemModelId);
                }
                if (null != itemBase)
                {
                    itemBase.ContainerType = type;
                    if (type == ContainerType.ITEM_LOCATION_IMMORTAL)
                    {
                        itemBase.Index = bpModel.GetNewImmortalEquipIndex();
                    }
                    long oldCount = 0;
                    var oldItem = bpModel.GetItemByUID<ItemBase>(itemBase.DBID);
                    if(oldItem != null)
                    {
                        oldCount = oldItem.Count;
                    }
                    var newCount = itemBase.Count;
                    retIndex = bpModel.UpdateItem(itemBase);
                    if(type == ContainerType.ITEM_LOCATION_BAG || type == ContainerType.ITEM_LOCATION_IMMORTAL)
                    {
                        GameCenter.LuaSystem.Adaptor.AddUseNewItem(itemBase, resonCode, newCount - oldCount);
                    }
                }
                if(pushEvent)
                {
                    UpdateContianerItems(type, itemBase);
                }
            }
            return retIndex;
        }
        /// <summary>
        /// 属性物品信息，如果没有则创建
        /// </summary>
        /// <param name="type"></param>
        /// <param name="item"></param>
        /// <returns></returns>
        public int UpdateItemFromContainer(ContainerType type, ItemBase item)
        {
            int retIndex = -1;
            ItemContianerModel bpModel = GetBackpackModelByType(type);
            if (null == bpModel)
            {
                bpModel = new ItemContianerModel();
                bpModel.ContainerType = type;
                _itemContianerDic.Add((int)type, bpModel);
            }
            if (null != bpModel && null != item)
            {
                ItemBase itemBase = null;
                var itemModel = item as ItemModel;
                var equip = item as Equipment;
                if (null != itemModel)
                {
                    itemBase = new ItemModel(itemModel);
                }
                else
                {
                    itemBase = new Equipment(equip);
                }

                if (null != itemBase)
                {
                    itemBase.ContainerType = type;
                    retIndex = bpModel.UpdateItem(itemBase);
                }
            }
            return retIndex;
        }
        /// <summary>
        /// 更新物品时，向对应容器发送更新信息
        /// </summary>
        /// <param name="type"></param>
        /// <param name="obj"></param>
        public void UpdateContianerItems(ContainerType type, object obj = null)
        {
            
            switch (type)
            {
                case ContainerType.ITEM_LOCATION_BAG:
                case ContainerType.ITEM_LOCATION_IMMORTAL:
                    GameCenter.PushFixEvent(LogicEventDefine.EVENT_BACKFORM_ITEM_UPDATE, obj);
                    break;
                case ContainerType.ITEM_LOCATION_STORAGE:
                    GameCenter.PushFixEvent(LogicEventDefine.EVENT_STORAGE_ITEM_UPDATE, obj);
                    break;
                case ContainerType.ITEM_LOCATION_EQUIP:
                case ContainerType.ITEM_LOCATION_BACKEQUIP:
                    GameCenter.PushFixEvent(LogicEventDefine.EVENT_EQUIPMENTFORM_ITEM_UPDATE, obj);
                    break;
                case ContainerType.ITEM_LOCATION_CLEAR:
                    GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_CLEARBAG_UPDATE, obj);
                    break;
            }
            
        }

        /// <summary>
        /// 更新容器时，更新对应form
        /// </summary>
        /// <param name="type"></param>
        /// <param name="obj"></param>
        public void UpdateContainerForm(ContainerType type, object obj = null)
        {
            switch (type)
            {
                case ContainerType.ITEM_LOCATION_BAG:
                case ContainerType.ITEM_LOCATION_IMMORTAL:
                    GameCenter.PushFixEvent(LogicEventDefine.EVENT_BACKFORM_UPDATE_ALL, obj);
                    break;
                case ContainerType.ITEM_LOCATION_STORAGE:
                    GameCenter.PushFixEvent(LogicEventDefine.EVENT_STORAGE_FORM_UPDATE, obj);
                    break;
                case ContainerType.ITEM_LOCATION_EQUIP:
                case ContainerType.ITEM_LOCATION_BACKEQUIP:
                    GameCenter.PushFixEvent(LogicEventDefine.EVENT_EQUIPMENTFORM_UPDATE_FORM, obj);
                    break;
                case ContainerType.ITEM_LOCATION_CLEAR:
                    GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_CLEARBAG_UPDATE, obj);
                    break;
            }
        }

        /// <summary>
        /// 根据绑定类型获取物品列表
        /// </summary>
        /// <typeparam name="T">物品类型，可能是物品或者装备</typeparam>
        /// <param name="type">容器类型</param>
        /// <param name="bind">是否绑定</param>
        /// <returns></returns>
        public List<ItemBase> GetItemListByBind(ContainerType type, bool bind)
        {
            _cacheList.Clear();
            ItemContianerModel bpModel = GetBackpackModelByType(type);
            if (null != bpModel)
            {
                var tmpList = bpModel.ItemsOfIndex;
                if (null != tmpList)
                {
                    var enumerator = tmpList.GetEnumerator();
                    try
                    {
                        while (enumerator.MoveNext())
                        {
                            var retItem = enumerator.Current.Value as ItemBase;
                            if (null != retItem && retItem.IsBind == bind)
                            {
                                _cacheList.Add(retItem);
                            }
                        }
                    }
                    finally
                    {
                        enumerator.Dispose();
                    }
                }
            }
            return _cacheList;
        }

        //获取物品列表，没有GC
        private static List<ItemBase> _cacheList = new List<ItemBase>();
        public List<ItemBase> GetItemListNOGC<T>(ContainerType type) where T : ItemBase
        {
            _cacheList.Clear();
            ItemContianerModel bpModel = GetBackpackModelByType(type);
            if (null != bpModel)
            {
                var eumerater = bpModel.ItemsOfUID.GetEnumerator();
                try
                {
                    while (eumerater.MoveNext())
                    {
                        if (eumerater.Current.Value is T)
                        {
                            _cacheList.Add(eumerater.Current.Value as ItemBase);
                        }
                    }
                }
                finally
                {
                    eumerater.Dispose();
                }
            }
            return _cacheList;
        }
        /// <summary>
        /// 根据物品大分类获取对应物品容器中的物品列表
        /// </summary>
        /// <typeparam name="T">物品类型，可能是物品或者装备</typeparam>
        /// <param name="type">容器类型</param>
        /// <param name="bigType">物品大类型</param>
        /// <returns></returns>
        public List<T> GetItemList<T>(ContainerType type, ItemBigType bigType) where T : ItemBase
        {
            ItemContianerModel bpModel = GetBackpackModelByType(type);
            if (null != bpModel)
            {
                List<T> baseList = new List<T>(bpModel.ItemsOfUID.Count);
                var enumerator = bpModel.ItemsOfUID.GetEnumerator();
                try
                {
                    while (enumerator.MoveNext())
                    {
                        T retItem = enumerator.Current.Value as T;
                        if (null != retItem)
                        {
                            baseList.Add(retItem);
                        }
                    }
                }
                finally
                {
                    enumerator.Dispose();
                }
                return baseList;
            }
            return new List<T>();
        }
        
        /// <summary>
        /// 获取容器所有物品
        /// </summary>
        /// <typeparam name="T">物品类型，可能是物品或者装备</typeparam>
        /// <param name="type">容器类型</param>
        /// <returns></returns>
        public List<T> GetItemList<T>(ContainerType type) where T : ItemBase
        {
            List<T> baseList = new List<T>();
            ItemContianerModel bpModel = GetBackpackModelByType(type);
            if (null != bpModel)
            {
                var tmpList = bpModel.ItemsOfIndex;
                if (null != tmpList)
                {
                    var enumerator = tmpList.GetEnumerator();
                    try
                    {
                        while (enumerator.MoveNext())
                        {
                            T retItem = enumerator.Current.Value as T;
                            if (null != retItem)
                            {
                                baseList.Add(retItem);
                            }
                        }
                    }
                    finally
                    {
                        enumerator.Dispose();
                    }
                }
            }
            return baseList;
        }

        /// <summary>
        /// 根据UID获取物品的cfgID
        /// </summary>
        /// <param name="type">容器类型</param>
        /// <param name="Uid">物品的UID</param>
        /// <returns></returns>
        public int GetItemCfgIdWithUID(ContainerType type, ulong Uid)
        {
            int cfgId = 0;
            ItemContianerModel bpModel = GetBackpackModelByType(type);
            if (null != bpModel)
            {
                ItemBase item = GetItemByUID<ItemBase>(type, Uid);
                if (null != item)
                {
                    cfgId = item.CfgID;
                }
            }
            return cfgId;
        }

        //根据UID以及容器类型 获取物品信息
        public T GetItemByUID<T>(ContainerType type, ulong uid) where T : ItemBase
        {
            T retItem = null;
            ItemContianerModel bpModel = GetBackpackModelByType(type);
            if (null != bpModel)
            {
                retItem = bpModel.GetItemByUID<T>(uid);
            }
            return retItem;
        }

        public ItemBase GetItemByUIDFormBag(ulong uid)
        {
            ItemBase retItem = null;
            ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_BAG);
            if (null != bpModel)
            {
                retItem = bpModel.GetItemByUID<ItemBase>(uid);
            }
            return retItem;
        }
        public ItemBase GetItemByUIDFormImmortalBag(ulong uid)
        {
            ItemBase retItem = null;
            ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_IMMORTAL);
            if (null != bpModel)
            {
                retItem = bpModel.GetItemByUID<ItemBase>(uid);
            }
            return retItem;
        }

        //根据物品所在位置以及容器类型，获取物品信息
        public T GetItemByIndex<T>(ContainerType type, int index) where T : ItemBase
        {
            T retItem = null;
            ItemContianerModel bpModel = GetBackpackModelByType(type);
            if (null != bpModel)
            {
                retItem = bpModel.GetItemByIndex<T>(index);
            }
            return retItem;
        }

        public List<ItemBase> GetItemListByCfgidNOGC<T>(ContainerType type, int cfgid) where T : ItemBase
        {
            _cacheList.Clear();
            ItemContianerModel bpModel = GetBackpackModelByType(type);
            if (null != bpModel)
            {
                var eumerater = bpModel.ItemsOfUID.GetEnumerator();
                try
                {
                    while (eumerater.MoveNext())
                    {
                        var item = eumerater.Current.Value as T;
                        if (null != item && item.CfgID == cfgid)
                        {
                            _cacheList.Add(item);
                        }
                    }
                }
                finally
                {
                    eumerater.Dispose();
                }
            }
            return _cacheList;
        }
        public List<ItemBase> GetItemListByCfgidNOGC(ContainerType type, int cfgid)
        {
            _cacheList.Clear();
            ItemContianerModel bpModel = GetBackpackModelByType(type);
            if (null != bpModel)
            {
                var eumerater = bpModel.ItemsOfUID.GetEnumerator();
                try
                {
                    while (eumerater.MoveNext())
                    {
                        var item = eumerater.Current.Value;
                        if (null != item && item.CfgID == cfgid)
                        {
                            _cacheList.Add(item);
                        }
                    }
                }
                finally
                {
                    eumerater.Dispose();
                }
            }
            return _cacheList;
        }
        //此方法和上面的方法一样，但是lua不支持泛型，这个重载方法用于给lua调用
        public List<ItemBase> GetItemListByCfgid(ContainerType type, int cfgid)
        {

            List<ItemBase> baseList = new List<ItemBase>();
            ItemContianerModel bpModel = GetBackpackModelByType(type);
            if (null != bpModel)
            {
                var tmpList = bpModel.ItemsOfIndex;
                if (null != tmpList)
                {
                    var enumerator = tmpList.GetEnumerator();
                    try
                    {
                        while (enumerator.MoveNext())
                        {
                            ItemBase retItem = enumerator.Current.Value as ItemBase;
                            if (null != retItem && retItem.CfgID == cfgid)
                            {
                                baseList.Add(retItem);
                            }
                        }
                    }
                    finally
                    {
                        enumerator.Dispose();
                    }
                }
            }
            return baseList;
        }

        /// <summary>
        /// 获取可合成道具列表
        /// </summary>
        /// <returns></returns>
        public List<ItemBase> GetCanSynthItemList()
        {
            List<ItemBase> baseList = new List<ItemBase>();
            ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_BAG);
            if (null != bpModel)
            {
                var tmpList = bpModel.ItemsOfIndex;
                if (null != tmpList)
                {
                    var enumerator = tmpList.GetEnumerator();
                    try
                    {
                        while (enumerator.MoveNext())
                        {
                            var retItem = enumerator.Current.Value;
                            if (retItem.Type == ItemType.Equip)
                                continue;
                            var modelItem = retItem as ItemModel;
                            if (null != modelItem && modelItem.ItemInfo != null && !string.IsNullOrEmpty(modelItem.ItemInfo.HechenTarget))
                            {
                                baseList.Add(modelItem);
                            }
                        }
                    }
                    finally
                    {
                        enumerator.Dispose();
                    }
                }
            }
            return baseList;
        }

        /// <summary>
        /// 获取可合成碎片列表
        /// </summary>
        /// <returns></returns>
        public List<ItemModel> GetCanSynthPieceList()
        {
            List<ItemModel> baseList = new List<ItemModel>();
            ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_BAG);
            if (null != bpModel)
            {
                var tmpList = bpModel.ItemsOfIndex;
                if (null != tmpList)
                {
                    var enumerator = tmpList.GetEnumerator();
                    try
                    {
                        while (enumerator.MoveNext())
                        {
                            var retItem = enumerator.Current.Value as ItemModel;
                            if (retItem == null)
                                continue;
                            if (retItem.Type == ItemType.Equip)
                                continue;
                            if (null != retItem && retItem.ItemInfo != null && !string.IsNullOrEmpty(retItem.ItemInfo.HechenTarget)
                                && retItem.Type == ItemType.SpecialPingZiItem)
                            {
                                baseList.Add(retItem);
                            }
                        }
                    }
                    finally
                    {
                        enumerator.Dispose();
                    }
                }
            }
            return baseList;
        }

        //根据礼物、材料物品ID列表获取背包中所有的物品列表
        public List<ItemModel> GetItemListByCfgidList(List<int> list)
        {
            if (list == null)
                return null;
            List<ItemModel> baseList = new List<ItemModel>();
            ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_BAG);
            if (null != bpModel)
            {
                var tmpList = bpModel.ItemsOfIndex;
                if (null != tmpList)
                {
                    var enumerator = tmpList.GetEnumerator();
                    try
                    {
                        while (enumerator.MoveNext())
                        {
                            var retItem = enumerator.Current.Value as ItemModel;
                            if (retItem == null)
                                continue;
                            if (retItem.Type == ItemType.Equip)
                                continue;
                            if (null != retItem && retItem.ItemInfo != null && list.Contains(retItem.CfgID))
                            {
                                baseList.Add(retItem);
                            }
                        }
                    }
                    finally
                    {
                        enumerator.Dispose();
                    }
                }
            }
            return baseList;
        }

        //根据cfgid获取某个道具的数量
        //默认为背包
        public long GetItemCountFromCfgId(int cfgId)
        {
            long ret = 0;
            var _contType = ContainerType.ITEM_LOCATION_BAG;
            var itemType = ItemBase.GetItemTypeByModelID(cfgId);
            if (itemType == ItemType.ImmortalEquip)
            {
                _contType = ContainerType.ITEM_LOCATION_IMMORTAL;
            }
            ItemContianerModel bpModel = GetBackpackModelByType(_contType);
            if (null != bpModel)
            {
                ret = bpModel.GetCountByCfgId(cfgId);
            }
            if (ret == 0)
            {
                ret = GetEconomyWithType(cfgId);
            }
            return ret;
        }        

        //删除道具
        public void DeleteItemFromContainer(ContainerType type, ulong uid)
        {
            ItemContianerModel bpModel = GetBackpackModelByType(type);
            if (null != bpModel)
            {
                ItemBase item = bpModel.GetItemByUID<ItemBase>(uid);
                bpModel.DeleteItem(uid);

                //删除一个物品成功后，需要关闭tips
                GameCenter.LuaSystem.Adaptor.CloseItemTips();

                UpdateContianerItems(type, item);
                GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_BACKFORM_ITEM_UNSELCT);
            }
        }

        //批量删除道具
        private IEnumerator DeleteItemListFromContainer(ContainerType type, List<ulong> uidList)
        {
            yield return null;
            ItemContianerModel bpModel = GetBackpackModelByType(type);
            if (null != bpModel && uidList != null)
            {
                for(int i = 0; i < uidList.Count; i++)
                {
                    ItemBase item = bpModel.GetItemByUID<ItemBase>(uidList[i]);
                    bpModel.DeleteItem(uidList[i]);

                    //删除一个物品成功后，需要关闭tips
                    GameCenter.LuaSystem.Adaptor.CloseItemTips();

                    UpdateContianerItems(type, item);
                    //GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_BACKFORM_ITEM_UNSELCT);
                    //GameCenter.PushFixEvent(LogicEventDefine.EVENT_ITEM_CHANGE_UPDATE, item.CfgID);
                }
            }
            GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_ITEM_DELETELIST_UPDATE, uidList);
        }

        /// <summary>
        /// 修改货币值
        /// </summary>
        /// <param name="type"></param>
        /// <param name="value"></param>
        private void ChangeEconomy(bool isNew, int type, long value, long changeValue = 0, int reson = 0)
        {   
            long aValue = 0;
            if (_enconomy.TryGetValue((int)type, out aValue))
            {
                _enconomy[(int)type] = value;
                var addValue = value - aValue;
                if(!isNew)
                {
                    if (type == ItemTypeCode.Exp)
                    {
                        if(changeValue >= 100)
                        {
                            //100一下经验不展示
                            GameCenter.LuaSystem.Adaptor.AddShowNewItem(reson, (int)type, changeValue);
                        }
                        if(changeValue > 0)
                            GameCenter.PushFixEvent(LogicEventDefine.EVENT_COIN_ADD_UPDATE, new object[] { (int)type, changeValue });
                    }
                    else
                    {
                        GameCenter.LuaSystem.Adaptor.AddShowNewItem(reson, (int)type, addValue);
                        if(addValue > 0)
                            GameCenter.PushFixEvent(LogicEventDefine.EVENT_COIN_ADD_UPDATE, new object[] { (int)type, addValue });
                    }
                }
            }
            else
            {
                _enconomy.Add((int)type, value);
            }           
        }

        /// <summary>
        /// 根据货币类型获取货币值
        /// </summary>
        /// <param name="type">此处为long型，主要是为了以后扩展</param>
        /// <returns></returns>
        public long GetEconomyWithType(int type)
        {
            long ret = 0;
            if (null != _enconomy)
            {
                _enconomy.TryGetValue((int)type, out ret);
            }
            return ret;
        }

        /// <summary>
        /// 整理背包，客户端自行整理
        /// </summary>
        /// <param name="type"></param>
        public void SortBag(ContainerType type)
        {
            ItemContianerModel bpModel = GetBackpackModelByType(type);
            if (bpModel != null)
                bpModel.SortBag();
        }
        #endregion

        #region //背包网络消息
        //玩家背包物品信息,上线和背包变化时返回给玩家
        public void GS2U_ResItemInfos(ResItemInfos result)
        {
            ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_BAG);
            ResItemInfos infos = result as ResItemInfos;
            if (null == bpModel)
            {
                bpModel = new ItemContianerModel();
                bpModel.ContainerType = ContainerType.ITEM_LOCATION_BAG;
                _itemContianerDic.Add((int)ContainerType.ITEM_LOCATION_BAG, bpModel);
            }
            else
            {
                if (GetBagSortTime(ContainerType.ITEM_LOCATION_BAG) == 0)
                {
                    SetBagSortTime(ContainerType.ITEM_LOCATION_BAG, 10);
                }
            }

            bpModel.Clear();
            bpModel.OpenedCount = infos.cellnum;
            bpModel.NowOpenIndex = infos.cellnum + 5;
            bpModel.UseTime = infos.cellTime;
            bpModel.IsInitializing = true;
            for (int i = 0; i < infos.itemInfoList.Count; i++)
            {
                UpdateItemFromContainer(ContainerType.ITEM_LOCATION_BAG, infos.itemInfoList[i], false, 0, false);
            }
            UpdateContainerForm(ContainerType.ITEM_LOCATION_BAG);

            bpModel.IsInitializing = false;

            //for (int i = 0; i < infos.itemInfoList.Count; ++i)
            //{
            //    GameCenter.PushFixEvent(LogicEventDefine.EVENT_ITEM_CHANGE_UPDATE, infos.itemInfoList[i].itemModelId);
            //}
            GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_ONLINE_ITEMINFO);
        }

        //物品新增
        public void GS2U_ResItemAdd(ResItemAdd result)
        {
            
            UpdateItemFromContainer(ContainerType.ITEM_LOCATION_BAG, result.itemInfo, true, result.reason);
            
            //发送新物品消息
            ItemBase itemBase = GetItemByUID<ItemBase>(ContainerType.ITEM_LOCATION_BAG, result.itemInfo.itemId);
            if (itemBase == null)
            {
                return;
            }

            GameCenter.PushFixEvent(LogicEventDefine.EVENT_BACKFORM_NEW_ITEM, itemBase);
            GameCenter.PushFixEvent(LogicEventDefine.EVENT_ITEM_CHANGE_UPDATE, result.itemInfo.itemModelId);
            if (itemBase.Type == ItemType.Equip)
                GameCenter.PushFixEvent(LogicEventDefine.EVENT_EQUIP_ADD, result.itemInfo.itemModelId);

            //展示物品获取效果
            GameCenter.LuaSystem.Adaptor.AddShowNewItem(result.reason, itemBase, itemBase.Count);
            CheckItemChangeMsg(result.itemInfo.itemModelId);
        }

        //物品信息改变
        public void GS2U_ResItemChange(ResItemChange result)
        {
            long oldCount = 0;
            ItemBase oldItem = GetItemByIndex<ItemBase>(ContainerType.ITEM_LOCATION_BAG, result.itemInfo.gridId);
            if (oldItem != null)
            {
                oldCount = oldItem.Count;
            }
            UpdateItemFromContainer(ContainerType.ITEM_LOCATION_BAG, result.itemInfo, false, result.reason);
            //if (result.itemInfo.cdTime > 0)
            //{
            //    var item = DeclareItem.Get(result.itemInfo.itemModelId);
            //    if (item == null)
            //    {
            //        return;
            //    }
            //    List<ItemBase> list = GetItemListByCDID<ItemBase>(item.CoolingTimeId, ContainerType.ITEM_LOCATION_BAG);
            //    for (int i = 0; i < list.Count; i++)
            //    {
            //        list[i].CDTime = result.itemInfo.cdTime;
            //        UpdateItemFromContainer(ContainerType.ITEM_LOCATION_BAG, list[i]);
            //    }
            //}
            GameCenter.PushFixEvent(LogicEventDefine.EVENT_ITEM_CHANGE_UPDATE, result.itemInfo.itemModelId);
            if (result.reason == 246)
            {
                GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_UI_EQUIPSKILLCOM_SUC, true);
            }

            ItemBase newItem = GetItemByIndex<ItemBase>(ContainerType.ITEM_LOCATION_BAG, result.itemInfo.gridId);
            if (newItem == null)
                return;
            long addCount = newItem.Count - oldCount;

            //展示物品获取效果
            GameCenter.LuaSystem.Adaptor.AddShowNewItem(result.reason, newItem, addCount);
            CheckItemChangeMsg(result.itemInfo.itemModelId);
        }

        //物品删除
        public void GS2U_ResItemDelete(ResItemDelete result)
        {
            int itemModelId = 0;
            int itemType = ItemType.UnDefine;
            ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_BAG);
            if (null != bpModel)
            {
                ItemBase item = GetItemByUID<ItemBase>(ContainerType.ITEM_LOCATION_BAG, result.itemId);
                if (null != item)
                {
                    itemModelId = item.CfgID;
                    itemType = item.Type;
                }
            }
            DeleteItemFromContainer(ContainerType.ITEM_LOCATION_BAG, result.itemId);
            GameCenter.PushFixEvent(LogicEventDefine.EVENT_ITEM_CHANGE_UPDATE, itemModelId);
            if (itemType == ItemType.Equip)
                GameCenter.PushFixEvent(LogicEventDefine.EVENT_EQUIP_DEL, itemModelId);
            CheckItemChangeMsg(itemModelId);
        }
        //物品删除 批量批除 在遇到需要大批量删除物品时，建议使用这条消息
        public void ResItemListDelete(ResItemListDelete result)
        {
            if(result.itemIds != null)
            {
                CoroutinePool.AddTask(DeleteItemListFromContainer(ContainerType.ITEM_LOCATION_BAG, result.itemIds));
            }
        }

        /// <summary>
        /// 货币信息
        /// </summary>
        /// <param name="result"></param>
        public void GS2U_ResCoinInfos(ResCoinInfos result)
        {
            ResCoinInfos coins = result as ResCoinInfos;
            for (int idx = 0; idx < coins.coinList.Count; ++idx)
            {
                ItemCoin coin = coins.coinList[idx];
                ChangeEconomy(true, coin.type, coin.value);
                GameCenter.PushFixEvent(LogicEventDefine.EVENT_COIN_CHANGE_UPDATE, coin.type);
            }
            //货币改变消息
            for (int idx = 0; idx < coins.coinList.Count; ++idx)
            {
                GameCenter.PushFixEvent(LogicEventDefine.EVENT_COIN_CHANGE_UPDATE, coins.coinList[idx].type);
            }
        }

        /// <summary>
        /// 货币改变
        /// </summary>
        /// <param name="result"></param>
        public void GS2U_ResCoinChange(ResCoinChange result)
        {
            ResCoinChange coinChange = result as ResCoinChange;
            if (coinChange.changeCoin.type == ItemTypeCode.Exp)
            {
                ChangeEconomy(false, coinChange.changeCoin.type, coinChange.changeCoin.value, 0, result.reason);
                var lp = GameCenter.GameSceneSystem.GetLocalPlayer();
                if (lp != null)
                {
                    lp.PropMoudle.Exp = (ulong)coinChange.changeCoin.value;
                }
            }
            else
            {
                //货币变化统计
                GameCenter.SDKSystem.ActionCoinChange(coinChange);
                ChangeEconomy(false, coinChange.changeCoin.type, coinChange.changeCoin.value, 0, result.reason);
            }
            
            GameCenter.PushFixEvent(LogicEventDefine.EVENT_COIN_CHANGE_UPDATE, coinChange.changeCoin.type);
        }

        /// <summary>
        /// 经验值的变化
        /// </summary>
        public void GS2U_ResExpChange(ResExpChange result)
        {
            ChangeEconomy(false, result.changeCoin.type, result.changeCoin.value, result.changeNum, result.reason);
            GameCenter.PushFixEvent(LogicEventDefine.EVENT_COIN_EXP_CHANGE_UPDATE, result.changeNum);
            var lp = GameCenter.GameSceneSystem.GetLocalPlayer();
            if (lp != null)
            {
                lp.PropMoudle.Exp = (ulong)result.changeCoin.value;
            }
        }

        /// <summary>
        /// 背包打开结果
        /// </summary>
        /// <param name="result"></param>

        public void GS2U_ResOpenBagCellSuccess(ResOpenBagCellSuccess result)
        {
            ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_BAG);
            if (null == bpModel)
            {
                bpModel = new ItemContianerModel();
                bpModel.ContainerType = ContainerType.ITEM_LOCATION_BAG;
                _itemContianerDic.Add((int)ContainerType.ITEM_LOCATION_BAG, bpModel);
            }

            bpModel.OpenedCount = result.nowCellId;
            bpModel.NowOpenIndex = bpModel.OpenedCount + 5;
            bpModel.UseTime = 0;
            GameCenter.PushFixEvent(LogicEventDefine.EID_EVENT_BAG_OPENCELL_UPDATE);
        }

        /// <summary>
        /// 背包打开失败
        /// </summary>
        /// <param name="result"></param>
        public void GS2U_ResOpenBagCellFailed(ResOpenBagCellFailed result)
        {
            GameCenter.MsgPromptSystem.ShowPrompt(DeclareMessageString.Get(DeclareMessageString.C_ITEM_OPENCELL_FIALD));
        }

        public void ResUseItemMakeBuff(ResUseItemMakeBuff result)
        {
            if(result.state == 0 || result.state == 1)
            {
                var list = GameCenter.ItemContianerSystem.GetItemListByCfgidNOGC<ItemBase>(ContainerType.ITEM_LOCATION_BAG, result.itemModelId);
                if(list.Count > 0)
                {
                    RequestUseItem(list[0].DBID);
                }
            }
            else if(result.state == 2)
            {
                GameCenter.MsgPromptSystem.ShowPrompt(Thousandto.Cfg.Data.DeclareMessageString.Get(Thousandto.Cfg.Data.DeclareMessageString.C_ITEM_EXPITEMISFOOD));
            }
            else
            {
                GameCenter.MsgPromptSystem.ShowMsgBox(Thousandto.Cfg.Data.DeclareMessageString.Get(Thousandto.Cfg.Data.DeclareMessageString.C_ITEM_EXPITEMFAILED), x =>
                {
                    if (x == MsgBoxResultCode.Button2)
                    {
                        var list = GameCenter.ItemContianerSystem.GetItemListByCfgidNOGC<ItemBase>(ContainerType.ITEM_LOCATION_BAG, result.itemModelId);
                        if (list.Count > 0)
                        {
                            RequestUseItem(list[0].DBID);
                        }
                    }
                });
            }
        }


        //网络请求
        public static void RequestUseItem(ulong uid, int num = 1)
        {
            ReqUseItem useItem = new ReqUseItem();
            useItem.itemId = uid;
            useItem.num = num;
            useItem.Send();
        }

        /// <summary>
        /// 删除物品
        /// </summary>
        /// <param name="uid"></param>
        public static void RequestDelItem(ulong uid)
        {
            MSG_backpack.ReqDelItem itemDelete = new MSG_backpack.ReqDelItem();
            itemDelete.itemId = uid;
            itemDelete.Send();
        }

        /// <summary>
        /// 背包清理
        /// </summary>
        public static void RequestClearUp()
        {
            ReqBagClearUp clearUP = new ReqBagClearUp();
            clearUP.Send();
        }

        /// <summary>
        /// 开启背包格子
        /// </summary>
        /// <param name="type"></param>
        /// <param name="targetIdx"></param>
        public static void RequestOpenCell(ContainerType type, int targetIdx)
        {

            switch (type)
            {
                case ContainerType.ITEM_LOCATION_BAG:
                    {
                        MSG_backpack.ReqOpenBagCell openCell = new MSG_backpack.ReqOpenBagCell();
                        openCell.cellId = targetIdx;
                        openCell.Send();
                    }
                    break;
            }

        }

        /// <summary>
        /// 请求分割物品
        /// </summary>
        /// <param name="uid"></param>
        /// <param name="num"></param>
        public static void RequestSqlitItem(ulong uid, int num)
        {
            ReqMoveItem sqlitItem = new ReqMoveItem();
            sqlitItem.itemId = uid;
            sqlitItem.num = num;
            sqlitItem.Send();
        }

        public static void RequestSellItem(ulong dbId, long num = 1)
        {
            if (dbId != 0)
            {
                ReqSellItems sellItems = new ReqSellItems();
                sellItems.itemId = dbId;
                sellItems.num = (int)num;
                sellItems.Send();
            }
        }

        /// <summary>
        /// 请求合成
        /// </summary>
        public static void RequestSynthItem(List<ulong> bindIdList, List<ulong> nonBindIDList, int type)
        {
            ReqCompound msg = new ReqCompound();
            if(bindIdList != null)
            {
                for (int i = 0; i < bindIdList.Count; i++)
                {
                    msg.bindId.Add(bindIdList[i]);
                }
            }
            if (nonBindIDList != null)
            {
                for (int i = 0; i < nonBindIDList.Count; i++)
                {
                    msg.nonBindId.Add(nonBindIDList[i]);
                }
            }
            msg.type = type;
            msg.Send();
        }
        #endregion

        #region //仓库网络消息
        public void GS2U_ResStoreItemInfos(MSG_store.ResStoreItemInfos result)
        {
            ItemContianerModel storeModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_STORAGE);
            if (null == storeModel)
            {
                storeModel = new ItemContianerModel();
                storeModel.ContainerType = ContainerType.ITEM_LOCATION_STORAGE;
                _itemContianerDic.Add((int)ContainerType.ITEM_LOCATION_STORAGE, storeModel);
            }
            else
            {
                if (GetBagSortTime(ContainerType.ITEM_LOCATION_STORAGE) == 0)
                {
                    SetBagSortTime(ContainerType.ITEM_LOCATION_STORAGE, 10);
                }
            }

            storeModel.Clear();
            storeModel.OpenedCount = result.cellnum;
            storeModel.NowOpenIndex = result.cellnum + 5;
            storeModel.UseTime = result.cellTime;
            for (int i = 0; i < result.itemInfoList.Count; i++)
            {
                UpdateItemFromContainer(ContainerType.ITEM_LOCATION_STORAGE, result.itemInfoList[i]);
            }

            UpdateContainerForm(ContainerType.ITEM_LOCATION_STORAGE);
        }

        public void GS2U_ResStoreItemAdd(MSG_store.ResStoreItemAdd result)
        {
            UpdateItemFromContainer(ContainerType.ITEM_LOCATION_STORAGE, result.itemInfo, true);
        }

        public void GS2U_ResStoreItemChange(MSG_store.ResStoreItemChange result)
        {
            UpdateItemFromContainer(ContainerType.ITEM_LOCATION_STORAGE, result.itemInfo);
        }

        public void GS2U_ResStoreItemDelete(MSG_store.ResStoreItemDelete result)
        {
            DeleteItemFromContainer(ContainerType.ITEM_LOCATION_STORAGE, result.itemId);
        }

        public void GS2U_ResOpenStoreCellSuccess(MSG_store.ResOpenStoreCellSuccess result)
        {
            ItemContianerModel bpModel = GetBackpackModelByType(ContainerType.ITEM_LOCATION_STORAGE);
            if (null == bpModel)
            {
                bpModel = new ItemContianerModel();
                bpModel.ContainerType = ContainerType.ITEM_LOCATION_STORAGE;
                _itemContianerDic.Add((int)ContainerType.ITEM_LOCATION_STORAGE, bpModel);
            }

            bpModel.OpenedCount = result.nowCellId;
            bpModel.NowOpenIndex = bpModel.OpenedCount + 5;
            bpModel.UseTime = 0;
            UpdateContainerForm(ContainerType.ITEM_LOCATION_STORAGE);
        }

        public void GS2U_ResOpenStoreCellFailed(MSG_store.ResOpenStoreCellFailed result)
        {
            GameCenter.MsgPromptSystem.ShowPrompt(DeclareMessageString.Get(DeclareMessageString.C_STOREGE_OPENCELL_FAILE));
        }

        public static void RequestToBag(int cellIdx)
        {
            MSG_store.ReqStoreToBag toBag = new MSG_store.ReqStoreToBag();
            toBag.cellId = cellIdx;
            toBag.Send();
        }

        public static void RequestToStore(int cellIdx)
        {
            MSG_store.ReqBagToStore toStore = new MSG_store.ReqBagToStore();
            toStore.cellId = cellIdx;
            toStore.Send();
        }

        #endregion
    
        #region //静态方法

        /// 根据物品id获取物品配置表中的信息
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="cfgid"></param>
        /// <returns></returns>
        public static T GetItemCfgWithID<T>(int cfgid) where T : ItemBase
        {
            ItemBase retItem = null;
            if (cfgid > 0)
            {
                retItem = ItemBase.CreateItemBase(cfgid);
            }

            return retItem as T;
        }

        /// <summary>
        /// 根据配置表获取背包或仓库最大格子数
        /// </summary>
        /// <param name="aType"></param>
        /// <returns></returns>
        public static int GetBagMaxCount(ContainerType aType)
        {
            int result = 0;
            int type = 1;
            if (aType == ContainerType.ITEM_LOCATION_BAG)
                type = 1;
            else
            {
                result = int.Parse(DeclareGlobal.Get((int)GlobalName.StoreCreateNum).Params);
                type = 2;
            }
            var e = DeclareBagGrid.CacheData.GetEnumerator();
            while(e.MoveNext())
            {
                if (e.Current.Value.Grid > result && e.Current.Value.Bag == type)
                    result = e.Current.Value.Grid;
            }
            return result;
        }
        #endregion
    }

    //物品改变定制消息
    public class ItemMsgCondition
    {
        private List<int> items;
        public List<int> Items
        {
            get
            {
                if (items == null)
                {
                    items = new List<int>();
                }
                return items;
            }
        }
        public int MsgID { get; private set; }

        public ItemMsgCondition(int msgID, int[] itemss)
        {
            MsgID = msgID;
            if (itemss == null || itemss.Length <= 0)
            {
                return;
            }
            for (int i = 0; i < itemss.Length; ++i)
            {
                Items.Add(itemss[i]);
            }
        }
        public void Check(int id)
        {
            if (Items.Contains(id))
                GameCenter.PushFixEvent(MsgID);
        }
    }
}