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

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace G
{
    /// <summary>
    /// 类功能描述
    /// </summary>
    public class BattlePassProxy : F.GameProxy
    {
        public class BattlePassLevelInfo
        {
            public readonly ItemBattlePassLevel item;
            public int id => item.id;
            /// <summary>
            /// 
            /// </summary>
            public int status
            {
                get
                {
                    return GlobalUtils.CombineNumber824(adStatus, freeStatus);
                }
                set
                {
                    GlobalUtils.SplitNumber824(value, out int ad, out int free);
                    adStatus = ad;
                    freeStatus = free;
                }
            }

            /// <summary>
            /// 0 等级不够 1 可以领取 2 已经领取
            /// </summary>
            public int freeStatus
            {
                get;
                set;
            }

            /// <summary>
            /// 
            /// </summary>
            public int adStatus
            {
                get;
                set;
            }

            /// <summary>
            /// 
            /// </summary>
            public bool isUnlock;

            /// <summary>
            /// 
            /// </summary>
            public bool hasRewardCollect
            {
                get { return freeStatus == 1 || adStatus == 1; }
            }
            /// <summary>
            /// 
            /// </summary>			
            /// <returns></returns>
            public bool CollectFreeReward()
            {
                if (freeStatus == 1)
                {
                    freeStatus = 2;
                    return true;
                }
                return false;
            }

            public bool CollectAdReward()
            {
                if (adStatus == 1)
                {
                    adStatus = 2;
                    return true;
                }
                return false;
            }

            public void SyncLevel(int level, bool activeAd)
            {
                if (id <= level)
                {
                    isUnlock = true;
                    if (freeStatus == 0)
                        freeStatus = 1;
                    if (activeAd && adStatus == 0)
                        adStatus = 1;
                }
                else
                    isUnlock = false;
            }

            public void Reset()
            {
                freeStatus = 0;
                adStatus = 0;
                isUnlock = false;
            }

            public BattlePassLevelInfo(ItemBattlePassLevel battlePassLevelItem)
            {
                this.item = battlePassLevelItem;
            }
        }

        #region Field

        private BattlePassLevelInfo[] _battlePassLevelInfos;

        private ItemBattlePass _battlePass;
        private bool _isActivation;

        public int level;
        public int exp;
        public int expMax;

        #endregion

        #region Property

        public bool isActivation => _isActivation;

        public string remainTimeString
        {
            get
            {
                return F.Utils.Time.ToTimeString(_battlePass.date - Launch.Timestamp);
            }
        }

        public int tokenCount
        {
            get
            {
                return MoneyProxy.Instance.GetMoney(_battlePass.unlockToken[0]);
            }
        }

        public int tokenCountMax
        {
            get
            {
                return _battlePass.unlockToken[1];
            }
        }

        #endregion

        #region Method

        /// <summary>
        /// 同步经验值
        /// </summary>
        public void SyncExp()
        {
            int t = MoneyProxy.Instance.GetMoney(Item.Id.kBattlePassExp);
            int index = 0;
            int curExpAcc = 0;
            int lastExpAcc = 0;
            do
            {
                level = index + 1;
                exp = t - curExpAcc;
                curExpAcc = _battlePassLevelInfos[index++].item.exp;
                expMax = curExpAcc - lastExpAcc;
                lastExpAcc = curExpAcc;
            } while (curExpAcc <= t && index < _battlePassLevelInfos.Length);

            SyncLevelInfo();
            SaveBattlePass();
        }

        private void SyncLevelInfo()
        {
            for (int i = 0; i < _battlePassLevelInfos.Length; i++)
            {
                _battlePassLevelInfos[i].SyncLevel(level, isActivation);
            }
        }

        public bool Activation()
        {
            var unlockToken = _battlePass.unlockToken;
            if (MoneyProxy.Instance.CheckAndCostMoney(unlockToken, GlobalDefine.COST_MONEY_BATTLE_PASS))
            {
                _isActivation = true;
                SaveBattlePass();
                return true;
            }
            else
            {
                PostNotification(GlobalDefine.EVENT_SHOW_TOAST, KLocalization.GetLocalString(3));
                return false;
            }
        }

        public void ResetAll()
        {
            MoneyProxy.Instance.AddMoney(Item.Id.kBattlePassExp, -MoneyProxy.Instance.GetMoney(Item.Id.kBattlePassExp));
            MoneyProxy.Instance.AddMoney(Item.Id.kBattlePassToken, -MoneyProxy.Instance.GetMoney(Item.Id.kBattlePassToken));

            _isActivation = false;
            level = 0;
            exp = 0;
            expMax = 1;
            for (int i = 0; i < _battlePassLevelInfos.Length; i++)
            {
                _battlePassLevelInfos[i].Reset();
            }
            SaveBattlePass();
        }

        public BattlePassLevelInfo[] GetBattlePassLevelInfos()
        {
            SyncLevelInfo();
            return _battlePassLevelInfos;
        }

        public void CollecReward(int id, bool ad, System.Action<int> callback)
        {
            var rewards = F.ListPool<Item.ItemInfo>.Get();
            var info = _battlePassLevelInfos[id - 1];
            if (info.id == id)
            {
                if (info.CollectFreeReward())
                {
                    rewards.AddRange(info.item.freeRewardInfos);
                    //Item.ItemInfo.FromArray(rewards, info.item.freeAwards);
                }
                if (ad && info.CollectAdReward())
                {
                    rewards.AddRange(info.item.adRewardInfos);
                    //Item.ItemInfo.FromArray(rewards, info.item.adAwards);
                }
            }

            if (rewards.Count > 0)
            {
                SaveBattlePass();
                RewardProxy.Instance.GetRewardsWithUI(rewards, (error, message) =>
                {
                });
            }
            F.ListPool<Item.ItemInfo>.Release(rewards);
            callback?.Invoke(0);
        }

        /// <summary>
        /// 领取batpass 奖励
        /// </summary>
        public void CollectAllRewards(Callback2 callback)
        {
            var rewards = F.ListPool<Item.ItemInfo>.Get();
            for (int i = 0; i < _battlePassLevelInfos.Length; i++)
            {
                var info = _battlePassLevelInfos[i];
                if (info.CollectFreeReward())
                {
                    rewards.AddRange(info.item.freeRewardInfos);
                    //Item.ItemInfo.FromArray(rewards, info.item.freeAwards);
                }
                if (info.CollectAdReward())
                {
                    rewards.AddRange(info.item.adRewardInfos);
                    //Item.ItemInfo.FromArray(rewards, info.item.adAwards);
                }
            }
            if (rewards.Count > 0)
            {
                SaveBattlePass();
                RewardProxy.Instance.GetRewardsWithUI(rewards, callback);
            }
            F.ListPool<Item.ItemInfo>.Release(rewards);
        }

        /// <summary>
        /// RedPointConst.BattlePassActivation
        /// </summary>
        /// <returns></returns>
        public int GetRedPoint1()
        {
            if (!_isActivation)
            {
                var unlockToken = _battlePass.unlockToken;
                if (MoneyProxy.Instance.CheckMoney(unlockToken))
                {
                    return 1;
                }
            }
            return 0;
        }
        /// <summary>
        /// RedPointConst.BattlePassMission
        /// </summary>
        /// <returns></returns>
        public int GetRedPoint2()
        {
            return MissionProxy.Instance.GetRedPointWeek();
        }
        /// <summary>
        /// RedPointConst.BattlePassReward
        /// </summary>
        /// <returns></returns>
        public int GetRedPoint3()
        {
            for (int i = 0; i < _battlePassLevelInfos.Length; i++)
            {
                if (_battlePassLevelInfos[i].hasRewardCollect)
                {
                    return 1;
                }
            }
            return 0;
        }

        public int GetRedPoint4()
        {
            if (GetRedPoint2() == 1)
            {
                return 1;
            }
            else
            {
                return GetRedPoint3();
            }
        }
        ItemBattlePass GetValidBattleBass()
        {
            var battlePasses = ItemProxy.Instance.GetStaticItems<ItemBattlePass>();
            var result = battlePasses[0];
            for (int i = 0; i < battlePasses.Count; i++)
            {
                if (Launch.Timestamp < battlePasses[i].date)
                {
                    result = battlePasses[i];
                    return result;
                }
            }
            return result;
        }

        private const string ARCHIVE_KEY_V1 = "battle_pass";

        /// <summary>
        /// 
        /// </summary>
        private void InitBattlePass()
        {
            _battlePass = GetValidBattleBass();

            if (_battlePassLevelInfos == null)
            {
                var bpLevels = ItemProxy.Instance.GetStaticItems<ItemBattlePassLevel>();
                if (bpLevels != null)
                {
                    _battlePassLevelInfos = new BattlePassLevelInfo[bpLevels.Count];
                    for (int i = _battlePassLevelInfos.Length - 1; i >= 0; i--)
                    {
                        _battlePassLevelInfos[i] = new BattlePassLevelInfo(bpLevels[i]);
                    }
                }
                else
                {
#if UNITY_EDITOR
                    Debug.LogError("battlepass error");
#endif
                }
            }
            else
            {
                for (int i = _battlePassLevelInfos.Length - 1; i >= 0; i--)
                {
                    _battlePassLevelInfos[i].Reset();
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        private void LoadBattlePass()
        {
            var dataList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_V1);
            if (dataList != null && dataList.Count > 0)
            {
                int index = 0;
                GlobalUtils.SplitNumber824(dataList.SafeGet(index++), out int ac, out int id);
                if (_battlePass.id != id)
                {
                    ResetAll();
                    return;
                    //reset
                }

                _battlePass = ItemProxy.Instance.GetStaticItem<ItemBattlePass>(id);
                _isActivation = ac != 0;
                for (int i = 0; i < _battlePassLevelInfos.Length; i++)
                {
                    _battlePassLevelInfos[i].status = dataList.SafeGet(index++);
                }
            }
            SyncExp();
        }

        /// <summary>
        /// 
        /// </summary>
        private void SaveBattlePass()
        {
            var dataList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_V1);
            if (dataList != null)
            {
                dataList.Clear();

                var bpInfo = GlobalUtils.CombineNumber824(_isActivation ? 1 : 0, _battlePass.id);
                dataList.Add(bpInfo);
                for (int i = 0; i < _battlePassLevelInfos.Length; i++)
                {
                    dataList.Add(_battlePassLevelInfos[i].status);
                }
                ArchiveProxy.Instance.SetIntList(ARCHIVE_KEY_V1, dataList);
            }
        }

        #endregion

        #region Proxy

        public static BattlePassProxy Instance => GetInstance<BattlePassProxy>();

        public override void ReadArchive()
        {
            InitBattlePass();
            LoadBattlePass();
        }

        #endregion
    }
}