// ***********************************************************************
// Assembly         : Game
// Author           : Kimch
// Created          : 2021-12-25
// Description      :
// Last Modified By : 
// Last Modified On : 
// ***********************************************************************
// <copyright file= "MoneyProxy" company="Kunpo"></copyright>
// <summary></summary>
// ***********************************************************************

using CodeStage.AntiCheat.ObscuredTypes;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace G
{
    /// <summary>
    /// 货币管理
    /// </summary>
    public class MoneyProxy : F.GameProxy
    {
        class MoneyInfo
        {
            public ObscuredInt lastAmount;
            public ObscuredInt lastChangeAmount;
            public int lastChangeSource;
        }

        #region Field

        /// <summary>
        /// 
        /// </summary>
        readonly Dictionary<int, MoneyInfo> _moneyInfoDict = new Dictionary<int, MoneyInfo>();

        #endregion

        #region Method

        /// <summary>
        /// 金币
        /// </summary>
        public int coin
        {
            get { return GetMoney(Item.Id.kCoin); }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="add"></param>
        public void AddCoin(int add, int source = 0)
        {
            AddMoney(Item.Id.kCoin, add);
        }

        /// <summary>
        ///钻石
        /// </summary>
        public int gem
        {
            get { return GetMoney(Item.Id.kGem); }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="add"></param>
        public void AddGem(int add)
        {
            AddMoney(Item.Id.kGem, add);
        }

        /// <summary>
        /// 碎片
        /// </summary>
        public int chip
        {
            get { return GetMoney(Item.Id.kChip); }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="add"></param>
        public void AddChip(int add)
        {
            AddMoney(Item.Id.kChip, add);
        }

        /// <summary>
        /// 套装石头
        /// </summary>
        public int stone
        {
            get { return GetMoney(Item.Id.kStone); }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="add"></param>
        public void AddStone(int add)
        {
            AddMoney(Item.Id.kStone, add);
        }

        /// <summary>
        /// 货币类型
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public int GetMoney(int id)
        {
            return ArchiveProxy.Instance.GetInt(id);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <param name="value"></param>
        public void AddMoney(int id, int value, int source = 0)
        {
            if (value == 0)
                return;

            int money = 0;
            int lastMoney = 0;

            if (id == Item.Id.kEnergy)
            {
                money = PlayerProxy.Instance.energy + value;
                PlayerProxy.Instance.energy = money;
            }
            else if (id == Item.Id.kMotility)
            {
                money = PlayerProxy.Instance.motility + value;
                PlayerProxy.Instance.motility = money;
            }
            else
            {
                lastMoney = ArchiveProxy.Instance.GetInt(id);
                money = Mathf.Max(0, lastMoney + value);
                ArchiveProxy.Instance.SetInt(id, money);

                if (id == Item.Id.kCoin || id == Item.Id.kStone || id == Item.Id.kGem || id == Item.Id.kChip || id == Item.Id.kLuckyBag || id == Item.Id.kAdTicket)
                {
                    if (_moneyInfoDict.TryGetValue(id, out var moneyInfo))
                    {
                        moneyInfo.lastAmount = lastMoney;
                        moneyInfo.lastChangeAmount = value;
                        moneyInfo.lastChangeSource = source;
                    }
                    else
                    {
                        moneyInfo = new MoneyInfo
                        {
                            lastAmount = lastMoney,
                            lastChangeAmount = value,
                            lastChangeSource = source,
                        };
                        _moneyInfoDict.Add(id, moneyInfo);
                    }

                    SaveMoney();
                }

                if (id == Item.Id.kCoin && value < 0)
                {
                    MissionProxy.Instance.OnEvent(MissionProxy.累计金币消耗类型, -value);
                }
            }

            var moneyItem = ItemProxy.Instance.GetStaticItem<ItemProp>(id);
            if (moneyItem != null)
                KStatistics.Instance.ReportEvent_Money(id, moneyItem.name, value > 0 ? 1 : 0, value, money, source.ToString());
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="itemInfo"></param>
        /// <returns></returns>
        public bool CheckMoney(Item.ItemInfo itemInfo)
        {
            return GetMoney(itemInfo.id) >= itemInfo.count;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <param name="count"></param>
        /// <returns></returns>
        public bool CheckMoney(int id, int count)
        {
            return GetMoney(id) >= count;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="price"></param>
        /// <returns></returns>
        public bool CheckMoney(int[] price)
        {
            var itemInfos = F.ListPool<Item.ItemInfo>.Get();
            Item.ItemInfo.FromArray(itemInfos, price);
            bool result = CheckMoney(itemInfos);
            F.ListPool<Item.ItemInfo>.Release(itemInfos);
            return result;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="itemInfos"></param>
        /// <returns></returns>
        public bool CheckMoney(IList<Item.ItemInfo> itemInfos)
        {
            foreach (var itemInfo in itemInfos)
            {
                if (!CheckMoney(itemInfo))
                {
                    return false;
                }
            }
            return true;
        }

        /// <summary>
        /// 返回不足的id
        /// </summary>
        /// <param name="itemInfos"></param>
        /// <returns></returns>
        public int CheckMoney2(IList<Item.ItemInfo> itemInfos)
        {
            foreach (var itemInfo in itemInfos)
            {
                if (GetMoney(itemInfo.id) < itemInfo.count)
                {
                    return itemInfo.id;
                }
            }
            return 0;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="id"></param>
        /// <param name="value"></param>
        public void CostMoney(int id, int value, int source = 0)
        {
            if (value > 0)
                AddMoney(id, -value, source);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="itemInfo"></param>
        public void CostMoney(Item.ItemInfo itemInfo, int source = 0)
        {
            CostMoney(itemInfo.id, itemInfo.count, source);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="itemInfos"></param>
        public void CostMoney(IList<Item.ItemInfo> itemInfos, int source = 0)
        {
            foreach (var itemInfo in itemInfos)
            {
                CostMoney(itemInfo.id, itemInfo.count, source);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="price"></param>
        public void CostMoney(int[] price, int source = 0)
        {
            var itemInfos = F.ListPool<Item.ItemInfo>.Get();
            Item.ItemInfo.FromArray(itemInfos, price);
            CostMoney(itemInfos, source);
            F.ListPool<Item.ItemInfo>.Release(itemInfos);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="costInfo"></param>
        /// <returns></returns>
        public bool CheckAndCostMoney(Item.ItemInfo costInfo, int source = 0)
        {
            bool enough = CheckMoney(costInfo);
            if (enough)
            {
                CostMoney(costInfo, source);
                return true;
            }
            return false;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="itemInfos"></param>
        /// <returns></returns>
        public bool CheckAndCostMoney(IList<Item.ItemInfo> itemInfos, int source = 0)
        {
            bool enough = CheckMoney(itemInfos);
            if (enough)
            {
                CostMoney(itemInfos, source);
                return true;
            }
            return false;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="cost"></param>
        /// <returns></returns>
        public bool CheckAndCostMoney(int[] cost, int source = 0)
        {
            var itemInfos = F.ListPool<Item.ItemInfo>.Get();
            Item.ItemInfo.FromArray(itemInfos, cost);
            bool result = CheckAndCostMoney(itemInfos, source);
            F.ListPool<Item.ItemInfo>.Release(itemInfos);
            return result;
        }

        #endregion

        #region Unity && Proxy && Archive

        private static MoneyProxy _Instance;
        public static MoneyProxy Instance => _Instance;// GetInstance<MoneyProxy>();
                                                       // Use this for initialization
        private void Awake()
        {
            _Instance = this;
        }

        public override void ReadArchive()
        {
            LoadMoney();
        }

        const string ARCHIVE_KEY_V1 = "money_v1";

        void InitMoney()
        {

        }

        void LoadMoney()
        {
            _moneyInfoDict.Clear();

            var dataList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_V1);
            if (dataList != null && dataList.Count > 0)
            {
                int maxIndex = dataList.Count - 4;
                for (int i = 0; i < maxIndex; i += 4)
                {
                    int mId = dataList[i];
                    int mAmount = dataList[i + 1];
                    int mChangeAmount = dataList[i + 2];
                    int mChangeSource = dataList[i + 3];

                    _moneyInfoDict.Add(mId, new MoneyInfo
                    {
                        lastAmount = mAmount,
                        lastChangeAmount = mChangeAmount,
                        lastChangeSource = mChangeSource,
                    });
                }
            }

            foreach (var item in _moneyInfoDict)
            {
                var money = ArchiveProxy.Instance.GetInt(item.Key);
                int checkMoney = item.Value.lastAmount + item.Value.lastChangeAmount;
                if (Mathf.Abs(money - checkMoney) > 1)
                {
                    ArchiveProxy.Instance.SetInt(item.Key, Mathf.Max(0, Mathf.Min(checkMoney, money)));
                }
            }
        }

        void SaveMoney()
        {
            var dataList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_V1);
            if (dataList != null)
            {
                dataList.Clear();
                foreach (var item in _moneyInfoDict)
                {
                    dataList.Add(item.Key);
                    dataList.Add(item.Value.lastAmount);
                    dataList.Add(item.Value.lastChangeAmount);
                    dataList.Add(item.Value.lastChangeSource);
                }

                ArchiveProxy.Instance.SetIntList(ARCHIVE_KEY_V1, dataList);
            }
        }



        #endregion
    }
}