using System.Collections.Generic;
using System.Linq;
using ET;
using FairyGUI;

namespace GFGGame
{
    public class ActivityInfo
    {
        public int ActivityId;

        public long StartTime;

        public long EndTime;

        //已经领取的奖励
        public List<int> GetRewards = new List<int>();

        //计数值
        public long CountValue;
        public int Type;
    }

    public class ActivityGlobalDataManager : SingletonBase<ActivityGlobalDataManager>
    {
        private readonly Dictionary<int, ActivityInfo> activityInfos = new Dictionary<int, ActivityInfo>();

        private readonly Dictionary<int, List<int>> activityInfosByType = new Dictionary<int, List<int>>();

        public void Clear()
        {
            activityInfos.Clear();
            activityInfosByType.Clear();
        }

        //添加活动数据
        public void AddActivityInfo(ActivityInfoProto activityInfoProto, bool dispatchEvent = true)
        {
            if (activityInfoProto == null) return;
            if (activityInfos.ContainsKey(activityInfoProto.ActivityId)) return;
            ActivityInfo activityInfo = new ActivityInfo();
            activityInfo.ActivityId = activityInfoProto.ActivityId;
            activityInfo.StartTime = activityInfoProto.StartTime;
            activityInfo.EndTime = activityInfoProto.EndTime;
            activityInfo.GetRewards = activityInfoProto.GetRewards;
            activityInfo.CountValue = activityInfoProto.CountValue;
            activityInfo.Type = activityInfoProto.Type;
            activityInfos.Add(activityInfo.ActivityId, activityInfo);

            if (!activityInfosByType.ContainsKey(activityInfo.Type))
            {
                activityInfosByType.Add(activityInfo.Type, new List<int>());
            }
            activityInfosByType[activityInfo.Type].Add(activityInfo.ActivityId);
            LogUtil.LogEditor($"AddActivityInfo {activityInfo.Type}");
            var remainTime = activityInfo.EndTime - TimeHelper.ServerNow();
            if (remainTime > 0)
            {
                //ACTIVITY_ADD
                if(dispatchEvent)
                {
                    EventAgent.DispatchEvent(ConstMessage.ACTIVITY_ADD);
                }
                Timers.inst.Add(activityInfo.EndTime - TimeHelper.ServerNow(), 1, ClientRemoveActivityInfo,
                    activityInfo.ActivityId);
            }
            else
            {
                ClientRemoveActivityInfo(activityInfo.ActivityId);
            }
        }

        private static void ClientRemoveActivityInfo(object param)
        {
            var activityId = (int)param;
            ActivityGlobalSProxy.ReqCloseActivity(activityId).Coroutine();
        }

        public void RemoveActivityInfo(int activityId)
        {
            if (!activityInfos.ContainsKey(activityId)) return;
            activityInfos.Remove(activityId);
            if (!activityInfosByType.ContainsKey(activityId)) return;
            activityInfosByType.Remove(activityId);
            //ACTIVITY_REMOVE
            EventAgent.DispatchEvent(ConstMessage.ACTIVITY_REMOVE, activityId);
        }

        //获取活动数据
        public ActivityInfo GetActivityInfo(int activityId)
        {
            if (!activityInfos.ContainsKey(activityId)) return null;
            return activityInfos[activityId];
        }

        //获取活动数据根据类型
        public List<int> GetActivityInfoIdsByType(int activityType)
        {
            return !activityInfosByType.ContainsKey(activityType) ? new List<int>() : activityInfosByType[activityType];
        }

        //获取活动数据根据类型
        public List<ActivityInfo> GetActivityInfoByType(int activityType)
        {
            var activityInfoIds = GetActivityInfoIdsByType(activityType);
            return activityInfoIds.Select(GetActivityInfo).Where(activityInfo => activityInfo != null).ToList();
        }

        public List<ActivityInfo> GetActivityInfoByTypeAndID(int activityType, int outActivityID)
        {
            List<ActivityOpenCfg> list = ActivityOpenCfgArray.Instance.GetCfgsBytype(activityType);
            List<int> infoList = new List<int>();
            for(int i = 0; i < list.Count; i++)
            {
                if(list[i].params2Arr!=null && list[i].params2Arr.Length > 0 
                    && list[i].params2Arr[0] == outActivityID)
                {
                    infoList.Add(list[i].id);
                }
            }
            return infoList.Select(GetActivityInfo).Where(activityInfo => activityInfo != null).ToList();
        }

        //获取活动数据根据类型
        public ActivityInfo GetActivityInfoOneByType(int activityType)
        {
            var activityInfoIds = GetActivityInfoIdsByType(activityType);
            return activityInfoIds.Select(GetActivityInfo).FirstOrDefault(activityInfo =>
                activityInfo != null && activityInfo.EndTime >TimeHelper.ServerNow());
        }

        //添加活动奖励获取数据
        public void AddActivityRewardInfo(int activityId, int rewardId)
        {
            if (!activityInfos.ContainsKey(activityId)) return;
            var activityInfo = activityInfos[activityId];
            if (activityInfo.GetRewards.Contains(rewardId)) return;
            activityInfo.GetRewards.Add(rewardId);
            EventAgent.DispatchEvent(ConstMessage.ACTIVITY_REWARD_ADD, activityId);
        }

        public void SetActivityCountValue(int activityId, long countValue)
        {
            if (!activityInfos.ContainsKey(activityId)) return;
            var activityInfo = activityInfos[activityId];
            activityInfo.CountValue = countValue;
            EventAgent.DispatchEvent(ConstMessage.ACTIVITY_COUNT_VALUE_CHANGE, activityId);
        }
     
        //根据活动id判断活动是否开启
        public bool IsActivityOpen(int activityId)
        {
            if (!activityInfos.ContainsKey(activityId)) return false;
            var activityInfo = activityInfos[activityId];
            return activityInfo.StartTime <= TimeHelper.ServerNow() && activityInfo.EndTime > TimeHelper.ServerNow();
        }
    }
}