//**********************************************//
//作者:#何健#
//日期:#2016.10.14#
//简述:#背包的模型，主要是一些数据#
//*********************************************//
using System.Collections.Generic;
using Thousandto.Cfg.Data;
using Thousandto.Code.Global;
using Thousandto.Core.Base;
using UnityEngine;
using System;
using Thousandto.Code.Center;

namespace Thousandto.Code.Logic
{
    /// <summary>
    /// 类BackPackModel说明
    /// </summary>
    public class ItemContianerModel
    {
        #region//常量
        //背包空格数量警告
        public const int BAG_SPACE_COUNT_WARNNING = 10;
        #endregion

        #region //私有变量
        private int _allCount;                  //总格子数
        private int _openedCount;               //已经打开的格子数
        private Dictionary<ulong, ItemBase> _itemsOfUid;                //uid
        private Dictionary<int, ItemBase> _itemsOfIndex;              //位置      
        private ContainerType _containerType;             //容器类型
        private int _nowOpenIndex;              //正在开启的格子下标
        private float _useTime;                   //使用的时间
        private int _remainSpaceCount = 0;      //格子的剩余数量
        private bool _isInitializing = false;    //是否正在初始化背包    
        private Dictionary<int, long> _itemCounts;//物品数量字典，用于存储物品数量以便使用
        #endregion   

        #region //属性
        public int AllCount
        {
            get
            {
                return _allCount;
            }
            set
            {
                _allCount = value;
            }
        }

        public int OpenedCount
        {
            get
            {
                return _openedCount;
            }
            set
            {
                _openedCount = value;
                UpdateRemainCount();
            }
        }

        public Dictionary<ulong, ItemBase> ItemsOfUID
        {
            get
            {
                return _itemsOfUid;
            }
            set
            {
                _itemsOfUid = value;
            }
        }

        public Dictionary<int, ItemBase> ItemsOfIndex
        {
            get
            {
                return _itemsOfIndex;
            }
            set
            {
                _itemsOfIndex = value;
            }
        }

        public int NowOpenIndex
        {
            get
            {
                return _nowOpenIndex;
            }
            set
            {
                _nowOpenIndex = value;
            }
        }

        public float UseTime
        {
            get
            {
                return _useTime;
            }
            set
            {
                _useTime = value;
            }
        }

        public ContainerType ContainerType
        {
            get
            {
                return _containerType;
            }
            set
            {
                _containerType = value;
            }
        }
        public int RemainSpaceCount
        {
            get { return _remainSpaceCount; }
        }

        //是否正在初始化
        public bool IsInitializing
        {
            get { return _isInitializing; }
            set { _isInitializing = value; }
        }
        public Dictionary<int, long> ItemCounts
        {
            get
            {
                return _itemCounts;
            }
        }
        #endregion

        #region//公共接口

        public ItemContianerModel()
        {
            _allCount = 0;
            _openedCount = 0;
            _itemsOfIndex = new Dictionary<int, ItemBase>(200);
            _itemsOfUid = new Dictionary<ulong, ItemBase>(200);
            _itemCounts = new Dictionary<int, long>(200);
            _useTime = 0;
            _nowOpenIndex = 0;
        }
        /// <summary>
        /// 根据DBID 获取物品信息
        /// </summary>
        /// <param name="uid"></param>
        /// <returns></returns>
        public T GetItemByUID<T>(ulong uid) where T : ItemBase
        {
            ItemBase ret = null;
            ItemsOfUID.TryGetValue(uid, out ret);
            return ret as T;
        }

        /// <summary>
        /// 根据物品在容器的位置来获取物品信息
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T GetItemByIndex<T>(int index) where T : ItemBase
        {
            ItemBase ret = null;
            ItemsOfIndex.TryGetValue(index, out ret);
            return ret as T;
        }

        /// <summary>
        /// 根据物品ID获取物品 ,获取容器的第一个。
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public T GetItemByID<T>(int id) where T : ItemBase
        {
            ItemBase ret = null;
            var eumerater = ItemsOfUID.GetEnumerator();
            try
            {
                while (eumerater.MoveNext())
                {
                    if (eumerater.Current.Value.CfgID == id)
                    {
                        ret = eumerater.Current.Value;
                        break;
                    }
                }
            }
            finally
            {
                eumerater.Dispose();
            }
            return ret as T;
        }

        /// <summary>
        /// 获取容器中所有为id的物品信息
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public List<T> GetItemListByCfgID<T>(int cfgId) where T : ItemBase
        {
            List<T> ret = new List<T>(ItemsOfUID.Count);
            var eumerater = ItemsOfUID.GetEnumerator();
            try
            {
                while (eumerater.MoveNext())
                {
                    if (eumerater.Current.Value.CfgID == cfgId)
                    {
                        ret.Add(eumerater.Current.Value as T);
                    }
                }
            }
            finally
            {
                eumerater.Dispose();
            }
            return ret;
        }


        /// <summary>
        /// 根据物品类型获取物品列表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="type"></param>
        /// <returns></returns>
        public List<T> GetItemListByType<T>(int type) where T : ItemBase
        {
            List<T> ret = new List<T>(ItemsOfUID.Count);
            var eumerater = ItemsOfUID.GetEnumerator();
            try
            {
                while (eumerater.MoveNext())
                {
                    var retItem = eumerater.Current.Value as T;
                    if (retItem == null)
                        continue;
                    if (type != ItemType.UnDefine)
                    {
                        if (eumerater.Current.Value.Type == type)
                            ret.Add(retItem);
                    }
                    else
                    {
                        if (eumerater.Current.Value.Type != ItemType.Equip && eumerater.Current.Value.Type != ItemType.ImmortalEquip)
                            ret.Add(retItem);
                    }
                }
            }
            finally
            {
                eumerater.Dispose();
            }
            return ret;
        }

        /// <summary>
        /// 获取容器中所有物品
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public List<T> GetItemList<T>() where T : ItemBase
        {
            List<T> ret = new List<T>(ItemsOfUID.Count);
            var eumerater = ItemsOfUID.GetEnumerator();
            try
            {
                while (eumerater.MoveNext())
                {
                    var item = eumerater.Current.Value as T;
                    if (null != item)
                    {
                        ret.Add(item);
                    }
                }
            }
            finally
            {
                eumerater.Dispose();
            }
            return ret;
        }

        /// <summary>
        /// 根据物品的大类型获取物品的列表
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public List<ItemBase> GetItemListByItemBigType(ItemBigType type)
        {
            List<ItemBase> ret = null;
            switch (type)
            {
                case ItemBigType.UnDefine:
                case ItemBigType.All:
                    {
                        ret = GetItemList<ItemBase>();
                    }
                    break;
                case ItemBigType.Equip:
                    {
                        ret = GetItemListByType<ItemBase>(ItemType.Equip);
                    }
                    break;
                case ItemBigType.ImmortalEquip:
                    {
                        ret = GetItemListByType<ItemBase>(ItemType.ImmortalEquip);
                    }
                    break;
                case ItemBigType.Other:
                    {
                        ret = GetItemListByType<ItemBase>(ItemType.UnDefine);
                    }
                    break;
            }
            ListSort(ret, true);
            return ret;
        }

        /// <summary>
        /// 根据物品的大类型获取某个位置的物品
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public ItemBase GetItemByBigTypeAndIndex(ItemBigType type, int index)
        {
            if (index < 0 || index >= ItemsOfUID.Count)
                return null;
            var eumerater = ItemsOfUID.GetEnumerator();
            try
            {
                int indexCounter = -1;
                while (eumerater.MoveNext())
                {
                    switch (type)
                    {
                        case ItemBigType.All:
                            {
                                ++indexCounter;
                            }
                            break;
                        case ItemBigType.Equip:
                            {
                                if (eumerater.Current.Value.Type == ItemType.Equip)
                                {
                                    ++indexCounter;
                                }
                            }
                            break;
                        case ItemBigType.ImmortalEquip:
                            {
                                if (eumerater.Current.Value.Type == ItemType.ImmortalEquip)
                                {
                                    ++indexCounter;
                                }
                            }
                            break;
                        case ItemBigType.Other:
                            {
                                if (eumerater.Current.Value.Type != ItemType.Equip && eumerater.Current.Value.Type != ItemType.ImmortalEquip)
                                {
                                    ++indexCounter;
                                }
                            }
                            break;
                    }

                    if (indexCounter == index)
                    {
                        return eumerater.Current.Value;
                    }
                }
            }
            finally
            {
                eumerater.Dispose();
            }
            return null;
        }

        /// <summary>
        /// 根据物品的大列表获取物品的字典容器
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="type"></param>
        /// <returns></returns>
        public Dictionary<int, T> GetItemDicByItemBigType<T>(ItemBigType type) where T : ItemBase
        {
            Dictionary<int, T> itemDic = new Dictionary<int, T>();
            var iter = _itemsOfIndex.GetEnumerator();
            try
            {
                while (iter.MoveNext())
                {
                    if (iter.Current.Value is T)
                    {
                        itemDic[iter.Current.Key] = iter.Current.Value as T;
                    }
                }
            }
            finally
            {
                iter.Dispose();
            }
            return itemDic;
        }

        //获取非绑定的物品
        public Dictionary<int, T> GetUnBoundItems<T>(ItemBigType type) where T : ItemBase
        {
            Dictionary<int, T> itemDic = new Dictionary<int, T>();

            var iter = _itemsOfIndex.GetEnumerator();
            try
            {
                while (iter.MoveNext())
                {
                    if (iter.Current.Value.IsBind == false)
                    {
                        itemDic[iter.Current.Key] = iter.Current.Value as T;
                    }
                }
            }
            finally
            {
                iter.Dispose();
            }
            return itemDic;
        }

        /// <summary>
        /// 更新物品信息，如果物品不存在则为创建新的，如果存在则会修改原来的值，由于没有多线程考虑，所以不会出现问题。
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public int UpdateItem(ItemBase item)
        {
            try
            {
                ItemBase oldItem = null;
                if (ItemsOfIndex.TryGetValue(item.Index, out oldItem))
                {
                    var dbId = oldItem.DBID;
                    ItemsOfIndex.Remove(item.Index);
                    ItemsOfUID.Remove(dbId);
                    ChangeCount(oldItem.CfgID, -oldItem.Count);
                }
                ItemsOfIndex.Add(item.Index, item);
                ItemsOfUID.Add(item.DBID, item);
                ChangeCount(item.CfgID, item.Count);
            }
            catch (Exception)
            {

            }

            return item.Index;
        }

        /// <summary>
        /// 删除物品
        /// </summary>
        /// <param name="uid">物品的唯一ID</param>
        /// <returns></returns>
        public void DeleteItem(ulong uid)
        {
            if (ItemsOfUID.ContainsKey(uid))
            {
                var item = ItemsOfUID[uid];
                ChangeCount(item .CfgID, -item.Count);
                ItemsOfIndex.Remove(item.Index);
                ItemsOfUID.Remove(uid);
            }
        }

        //清空数据
        public void Clear()
        {
            ItemsOfIndex.Clear();
            ItemsOfUID.Clear();
            ItemCounts.Clear();
        }

        public int GetNewImmortalEquipIndex()
        {
            int index = 1;
            for (int i = 1; i <= AllCount; i++)
            {
                if (!ItemsOfIndex.ContainsKey(i))
                {
                    index = i;
                    break;
                }
            }
            return index;
        }

        public void SortBag()
        {
            var list = new List<ItemBase>();
            var e = ItemsOfIndex.GetEnumerator();
            while (e.MoveNext())
            {
                list.Add(e.Current.Value);
            }
            ItemsOfIndex.Clear();
            for (int i = 0; i < list.Count; i++)
            {
                list[i].Index = i + 1;
                ItemsOfIndex.Add(i + 1, list[i]);
            }
        }

        //根据配置id获取数量
        public long GetCountByCfgId(int cfgId)
        {
            long result = 0;
            ItemCounts.TryGetValue(cfgId, out result);
            return result;
        }
        #endregion

        #region //私有方法

        /// <summary>
        /// 获取除装备和材质之外的物品
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        private List<T> GetOtherItems<T>() where T : ItemBase
        {
            List<T> ret = new List<T>(ItemsOfUID.Count);
            var eunmerater = ItemsOfUID.GetEnumerator();
            try
            {
                while (eunmerater.MoveNext())
                {
                    if (eunmerater.Current.Value.Type != ItemType.Material && eunmerater.Current.Value.Type != ItemType.Equip)
                    {
                        var item = eunmerater.Current.Value as T;
                        if (null != item)
                        {
                            ret.Add(item);
                        }
                    }
                }
            }
            finally
            {
                eunmerater.Dispose();
            }
            return ret;
        }

        //更新剩余数量
        private void UpdateRemainCount()
        {
            var newCnt = _openedCount - _itemsOfIndex.Count;
            if (_remainSpaceCount != newCnt)
            {
                //只针对背包进行更新
                if (_containerType == Global.ContainerType.ITEM_LOCATION_BAG)
                {
                    if (_remainSpaceCount < newCnt)
                    {
                        _remainSpaceCount = newCnt;
                        //空格增加
                        GameCenter.PushFixEvent((int)LogicEventDefine.EID_EVENT_WARINGBACKPACKCHANGE, false);

                    }
                    else
                    {
                        if (!IsInitializing)
                        {
                            _remainSpaceCount = newCnt;
                            //空格减少 
                            GameCenter.PushFixEvent((int)LogicEventDefine.EID_EVENT_WARINGBACKPACKCHANGE, true);
                        }
                        else
                        {
                            if (newCnt < BAG_SPACE_COUNT_WARNNING)
                            {
                                _remainSpaceCount = newCnt;
                                GameCenter.PushFixEvent((int)LogicEventDefine.EID_EVENT_WARINGBACKPACKCHANGE, true);
                            }
                        }
                    }
                }
                _remainSpaceCount = newCnt;
            }
        }

        private static int SortAsc(ItemBase left, ItemBase right)
        {
            return left.Index.CompareTo(right.Index);
        }

        //改变数量计数器
        private void ChangeCount(int cfgId, long count)
        {
            long curCount = 0;
            ItemCounts.TryGetValue(cfgId, out curCount);
            curCount += count;
            if(curCount < 0)
            {
                curCount = 0;
            }
            ItemCounts[cfgId] = curCount;
        }
        private static int SortDesc(ItemBase left, ItemBase right)
        {
            return right.Index.CompareTo(left.Index);
        }
        /// <summary>
        /// 对列表进行排序
        /// </summary>
        /// <param name="field">对要排序的item的字段</param>
        /// <param name="rule">排序规则</param>
        public static void ListSort(List<ItemBase> list, bool isAsc)
        {
            if (list != null)
            {
                if (isAsc)
                {
                    list.Sort(SortAsc);
                }
                else
                {
                    list.Sort(SortDesc);
                }
            }
        }
        #endregion
    }
}