using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using System.Linq;
using LitJson;


public partial class BattlePassManager : GameSystemManager<BattlePassManager>
{
    //战令类型：战令数据
    Dictionary<int, BattlePassData> battlePassDataDict = new Dictionary<int, BattlePassData>();
    public event Action<int> BattlePassDataUpdateEvent;


    Dictionary<int, int[]> buyZhanlingTypeDict = new Dictionary<int, int[]>();


    public override void Init()
    {
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent += OnBeforePlayerDataInitialize;
        PlayerDatas.Instance.playerDataRefreshEvent += OnPlayerDataRefresh;
        DTC0403_tagPlayerLoginLoadOK.playerLoginOkEvent += OnPlayerLoginOk;
        BlessLVManager.Instance.OnBlessLVUpdateEvent += OnBlessLVUpdateEvent;
        ParseConfig();
    }

    public override void Release()
    {
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent -= OnBeforePlayerDataInitialize;
        PlayerDatas.Instance.playerDataRefreshEvent -= OnPlayerDataRefresh;
        DTC0403_tagPlayerLoginLoadOK.playerLoginOkEvent -= OnPlayerLoginOk;
        BlessLVManager.Instance.OnBlessLVUpdateEvent -= OnBlessLVUpdateEvent;
    }

    void OnBeforePlayerDataInitialize()
    {
        battlePassDataDict.Clear();
    }

    void ParseConfig()
    {
        var config = FuncConfigConfig.Get("Zhanling");
        buyZhanlingTypeDict = ConfigParse.ParseIntArrayDict(config.Numerical1);
        battlePassTypeSortList = JsonMapper.ToObject<int[]>(config.Numerical5);

        foreach (var type in battlePassTypeSortList)
        {
            redpointCommonDict[type] = new Redpoint(MainRedDot.RedPoint_FundKey, MainRedDot.RedPoint_FundKey * 100 + type);
        }
    }


    public void UpdateBattlePassInfo(HB120_tagMCZhanlingInfo netPack)
    {
        if (!battlePassDataDict.ContainsKey(netPack.ZhanlingType))
        {
            battlePassDataDict[netPack.ZhanlingType] = new BattlePassData();
        }

        BattlePassData battlePassData = battlePassDataDict[netPack.ZhanlingType];
        battlePassData.isActivite = netPack.IsActivite;
        battlePassData.isActiviteH = netPack.IsActiviteH;
        battlePassData.allFinishTime = netPack.AllFinishTime;
        battlePassData.value1 = netPack.Value1;

        for (int i = 0; i < netPack.RewardCount; i++)
        {
            HB120_tagMCZhanlingInfo.tagMCZhanling reward = netPack.RewardList[i];
            if (!battlePassData.battlePassCellDict.ContainsKey((int)reward.NeedValue))
            {
                battlePassData.battlePassCellDict[(int)reward.NeedValue] = new BattlePassAwardState();
            }

            BattlePassAwardState battlePassCell = battlePassData.battlePassCellDict[(int)reward.NeedValue];
            battlePassCell.freeRewardState = reward.FreeRewardState;
            battlePassCell.zlRewardState = reward.ZLRewardState;
            battlePassCell.zlRewardStateH = reward.ZLRewardStateH;
        }

        UpdateRedpoint(netPack.ZhanlingType);
        BattlePassDataUpdateEvent?.Invoke(netPack.ZhanlingType);
    }

    #region 红点

    void OnBlessLVUpdateEvent()
    {
        UpdateCommonBPRedpoint(2);
    }

    void OnPlayerDataRefresh(PlayerDataType type)
    {
        switch (type)
        {
            case PlayerDataType.LV:
            case PlayerDataType.ExAttr1:
                {
                    UpdateCommonBPRedpoint(1);
                    UpdateCommonBPRedpoint(3);
                    break;
                }
        }
    }

    void OnPlayerLoginOk()
    {
        foreach (var type in battlePassTypeSortList)
        {
            UpdateCommonBPRedpoint(type);
        }
    }



    void UpdateRedpoint(int type)
    {
        switch ((BattlePassType)type)
        {
            case BattlePassType.LV:
            case BattlePassType.BlessLV:
            case BattlePassType.MainLine:
            case BattlePassType.GuBao:
            case BattlePassType.Arena:
                {
                    UpdateCommonBPRedpoint(type);
                    break;
                }
            case BattlePassType.Week:
                {
                    UpdateWeekRedPoint();
                    break;
                }
        }
    }

    
    
    #endregion
    //是否有任何奖励可以领取
    public bool HasAnyAward(int type, int totalValue)
    {
        battlePassDataDict.TryGetValue(type, out BattlePassData battlePassData);
        if (battlePassData == null)
            return false;
        if (battlePassData.allFinishTime != 0)
            return false;
        var allZhanling = ZhanlingConfig.GetTypeToIDDict(type);

        var keys = allZhanling.Keys.ToList();
        keys.Sort();
        foreach (var needValue in keys)
        {
            if (totalValue < needValue)
            {
                return false;
            }

            if (battlePassData.battlePassCellDict.ContainsKey(needValue))
            {
                if (battlePassData.battlePassCellDict[needValue].freeRewardState == 0)
                {
                    return true;
                }
                else if (battlePassData.isActivite != 0 && battlePassData.battlePassCellDict[needValue].zlRewardState == 0)
                {
                    return true;
                }
                else if (battlePassData.isActiviteH != 0 && battlePassData.battlePassCellDict[needValue].zlRewardStateH == 0)
                {
                    return true;
                }
            }
        }

        return false;
    }

    /// <summary>
    /// 是否有某个奖励可以领取
    /// </summary>
    /// <param name="battlePassData"></param>
    /// <param name="totalValue"></param>
    /// <param name="needValue"></param>
    /// <param name="awardType">0 免费 1 普通 2 高级</param>
    /// <returns>0 未达标 1 可领取 2 已领取</returns>
    public int GetBPCellAwardState(BattlePassData battlePassData, int totalValue, int needValue, int awardType)
    {
        if (totalValue < needValue)
        {
            return 0;
        }

        if (battlePassData.battlePassCellDict.ContainsKey(needValue))
        {
            switch (awardType)
            {
                case 0:
                    {
                        return battlePassData.battlePassCellDict[needValue].freeRewardState == 0 ? 1 : 2;
                    }
                case 1:
                    {
                        if (battlePassData.isActivite != 0)
                        {
                            return battlePassData.battlePassCellDict[needValue].zlRewardState == 0 ? 1 : 2;
                        }
                        break;
                    }
                case 2:
                    {
                        if (battlePassData.isActiviteH != 0)
                        {
                            return battlePassData.battlePassCellDict[needValue].zlRewardStateH == 0 ? 1 : 2;
                        }
                        break;
                    }
            }
        }
        return 0;
    }


    public int GetCTGIDByType(int type)
    {
        if (buyZhanlingTypeDict.ContainsKey(type))
        {
            return buyZhanlingTypeDict[type][0];
        }
        return 0;
    }


    public BattlePassData GetBattlePassData(int type)
    {
        if (battlePassDataDict.ContainsKey(type))
        {
            return battlePassDataDict[type];
        }
        return null;
    }


    //发包 type 0-免费；1-普通战令；2-高级战令
    public void SendGetGift(int zhanLingType, int needValue, int type)
    {
        var pak = new CA504_tagCMPlayerGetReward();
        string dataExStr = (needValue * 10 + type).ToString();
        pak.RewardType = (byte)65;
        pak.DataEx = (uint)zhanLingType;
        pak.DataExStrLen = (byte)dataExStr.Length;
        pak.DataExStr = dataExStr;
        GameNetSystem.Instance.SendInfo(pak);
    }

    //一次性全领取
    public void GetAllAward(BattlePassData battlePassData, int zhanLingType, int totalValue)
    {
        //简单判断背包
        if (PackManager.Instance.GetEmptyGridCount(PackType.Item) <= 1)
        {
            SysNotifyMgr.Instance.ShowTip("GeRen_lhs_202580");
            return;
        }
        var ids = ZhanlingConfig.GetTypeToIDDict(zhanLingType).Values.ToList();
        ids.Sort();
        foreach (var id in ids)
        {
            var config = ZhanlingConfig.Get(id);
            if (config.NeedValue > totalValue)
            {
                break;
            }

            for (int i = 0; i < 3; i++)
            {

                var state = GetBPCellAwardState(battlePassData, totalValue, config.NeedValue, i);
                if (state == 1)
                {
                    SendGetGift(zhanLingType, config.NeedValue, i);
                }
            }

        }

    }

    public int JumpIndex(BattlePassData battlePassData, int zhanLingType, int totalValue)
    {

        var ids = ZhanlingConfig.GetTypeToIDDict(zhanLingType).Values.ToList();
        ids.Sort();
        int index = -1;
        foreach (var id in ids)
        {
            index++;
            var config = ZhanlingConfig.Get(id);
            if (config.NeedValue > totalValue)
            {
                return index - 1;
            }

            for (int i = 0; i < 3; i++)
            {
                var state = GetBPCellAwardState(battlePassData, totalValue, config.NeedValue, i);
                if (state == 1)
                {
                    return index;
                }
            }
        }
        return index;
    }

    //是否全部完成(奖励全领取)
    public bool IsAllFinish(int type)
    {
        battlePassDataDict.TryGetValue(type, out BattlePassData battlePassData);
        if (battlePassData == null)
            return false;
        if (battlePassData.allFinishTime != 0)
            return true;
        return false;
    }

    public int GetTotalValue(int _type)
    {
        battlePassDataDict.TryGetValue(_type, out BattlePassData battlePassData);
        switch ((BattlePassType)_type)
        {
            case BattlePassType.LV:
                {
                    return PlayerDatas.Instance.baseData.LV;
                }
            case BattlePassType.BlessLV:
                {
                    return BlessLVManager.Instance.m_TreeLV;
                }
            case BattlePassType.MainLine:
                {
                    return PlayerDatas.Instance.baseData.ExAttr1 / 100;
                }
            case BattlePassType.GuBao:
                {
                    return (int)battlePassData.value1;
                }
            case BattlePassType.Arena:
                {
                    return (int)battlePassData.value1;
                }
            case BattlePassType.Week:
                {
                    return (int)battlePassData.value1;
                }
        }
        return 0;       
    }
}


public class BattlePassAwardState
{
    public byte freeRewardState;        // 免费战令奖励是否已领取
    public byte zlRewardState;        // 普通战令奖励是否已领取
    public byte zlRewardStateH;        // 高级战令奖励是否已领取
}


public class BattlePassData
{
    public byte isActivite;    // 普通战令是否已激活
    public byte isActiviteH;    // 高级战令是否已激活
    public uint allFinishTime;    // 全部奖励领取完毕的时间戳，未完毕时该值为0，后端会在0点过天时检查可否重置，前端自行做倒计时表现即可
    public uint value1;    // 战令对应的自定义值，可选，如登录战令代表开始计算日期时间戳

    public Dictionary<int, BattlePassAwardState> battlePassCellDict = new Dictionary<int, BattlePassAwardState>();
}

public enum BattlePassType
{
    LV = 1, //等级
    BlessLV = 2,    //祝福等级
    MainLine = 3,    //主线关卡
    GuBao = 4,   //古宝
    Arena = 5,   //演武场
    Week = 6,    //周战令
}