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


public class DayMissionManager : GameSystemManager<DayMissionManager>
{

    public int activityTotal;    // 今日累计获得活跃度
    public int activityAward;    // 累计活跃领奖记录，按活跃ID奖励二进制位存储是否已领取
    public int dailyTaskState;    // 今日任务是否已领取奖励，按任务ID二进制位存储是否已领取
    public Dictionary<int, Dictionary<int, int>> taskProcessDict = new Dictionary<int, Dictionary<int, int>>();    // 任务进度字典，key:任务类型，value:进度值
    public event Action OnDayMissionEvent;  // 日常任务事件

    public List<int> dailyIDList = new List<int>();

    bool isRefreshDayMission = false;   //做个延迟刷新

    public override void Init()
    {
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent += OnBeforePlayerDataInitialize;
        GlobalTimeEvent.Instance.MS100Event += OnMSEvent;

        ParseConfig();
    }

    public override void Release()
    {
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent -= OnBeforePlayerDataInitialize;
        GlobalTimeEvent.Instance.MS100Event -= OnMSEvent;
    }

    void OnBeforePlayerDataInitialize()
    {
        activityTotal = 0;
        activityAward = 0;
        dailyTaskState = 0;
        taskProcessDict.Clear();
    }

    void OnMSEvent()
    {
        if (isRefreshDayMission)
        {
            isRefreshDayMission = false;
            UpdateRedpoint();
            OnDayMissionEvent?.Invoke();
        }
    }
    void ParseConfig()
    {
        dailyIDList = DailyTaskConfig.GetKeys();
    }

    public void UpdateDailyTaskInfo(HB109_tagSCDailyTaskInfo netPack)
    {
        if (netPack.TaskCount > 4)
        {
            //4是随便写的 正常刷新包小于等于1，只有重登和过天会将所有同步一次
            //日常活跃包会被战斗包包含打乱顺序，故按最大值存储
            activityTotal = 0;
            activityAward = 0;
            dailyTaskState = 0;
            taskProcessDict.Clear();
        }
        activityTotal = Math.Max(activityTotal, (int)netPack.ActivityTotal);
        activityAward = Math.Max(activityAward, (int)netPack.ActivityAward);
        dailyTaskState = Math.Max(dailyTaskState, (int)netPack.DailyTaskState);
        for (int i = 0; i < netPack.TaskCount; i++)
        {
            var task = netPack.TaskList[i];
            if (!taskProcessDict.ContainsKey(task.TaskType))
            {
                taskProcessDict[task.TaskType] = new Dictionary<int, int>();

            }
            int cond = 0;
            if (!task.Conds.IsNullOrEmpty())
            {
                // 暂时按单条件规则存储，后续有变化再定义
                cond = (int)task.Conds[0];
            }
            if (!taskProcessDict[task.TaskType].ContainsKey(cond))
            {
                taskProcessDict[task.TaskType][cond] = 0;
            }
            taskProcessDict[task.TaskType][cond] = Math.Max(taskProcessDict[task.TaskType][cond], (int)task.CurValue);
        }
        isRefreshDayMission = true;
        // UpdateRedpoint();
        // OnDayMissionEvent?.Invoke();
    }

    public int GetDailyTaskProcess(int id)
    {
        var config = DailyTaskConfig.Get(id);
        if (!taskProcessDict.ContainsKey(config.TaskType))
        {
            return 0;
        }
        var cond = 0;
        if (!config.TaskConds.IsNullOrEmpty())
        {
            // 暂时按单条件规则存储，后续有变化再定义
            cond = config.TaskConds[0];
        }

        if (!taskProcessDict[config.TaskType].ContainsKey(cond))
        {
            return 0;
        }
        return taskProcessDict[config.TaskType][cond];
    }

    Redpoint redpoint = new Redpoint(MainRedDot.RedPoint_DailyKey, MainRedDot.RedPoint_DailyFuncKey);
    void UpdateRedpoint()
    {
        if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.DayMission))
        {
            return;
        }
        //累积奖励 和 可领取任务奖励任一
        redpoint.state = RedPointState.None;
        foreach (var config in DailyLivenessRewardConfig.GetValues())
        {
            if (GetDayActivityState(config) == 1)
            {
                redpoint.state = RedPointState.Simple;
                return;
            }
        }

        foreach (var config in DailyTaskConfig.GetValues())
        {
            if (GetDailyTaskState(config) == 1)
            {
                redpoint.state = RedPointState.Simple;
                return;
            }
        }
    }

    //总活跃奖励：0 未达标 1 可领取 2 已领取
    public int GetDayActivityState(DailyLivenessRewardConfig config)
    {
        if (activityTotal < config.NeedLiveness)
        {
            return 0;
        }
        if (((1 << config.ID) & activityAward) == 0)
        {
            return 1;
        }
        return 2;
    }

    //每日任务奖励：0 未达标 1 可领取 2 已领取
    public int GetDailyTaskState(DailyTaskConfig config)
    {
        if (GetDailyTaskProcess(config.TaskID) < config.NeedValue)
        {
            return 0;
        }
        if (((1 << config.TaskID) & dailyTaskState) == 0)
        {
            return 1;
        }
        return 2;
    }


    public void SortDailyTask()
    {
        dailyIDList.Sort(CmpDayTask);
    }

    // 可领取 》 已领取 》 未达标
    List<int> indexs = new List<int>() { 1, 0, 2 };
    int CmpDayTask(int idA, int idB)
    {
        var configA = DailyTaskConfig.Get(idA);

        var configB = DailyTaskConfig.Get(idB);

        var stateA = GetDailyTaskState(configA);
        var stateB = GetDailyTaskState(configB);
        var indexA = indexs.IndexOf(stateA);
        var indexB = indexs.IndexOf(stateB);

        if (indexA != indexB)
        {
            return indexA.CompareTo(indexB);
        }

        return idA.CompareTo(idB);
    }


}