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

using UnityEngine;
namespace vnxbqy.UI
{
    
    
    public class FestivalRedpackModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk, IOpenServerActivity
    {
        Dictionary<int, FestivalRedpack> festivalRedpacks = new Dictionary<int, FestivalRedpack>();
        Dictionary<int, List<FestivalRedpackAchievement>> achievements = new Dictionary<int, List<FestivalRedpackAchievement>>();
        List<int> taskRedpacks = new List<int>();

        bool serverInited = false;

        public List<int> systemDisplayRedpacks = new List<int>();
        public List<FestivalRedpackAchievement> displayAchievements = new List<FestivalRedpackAchievement>();
        public List<int> taskDisplayRedpacks = new List<int>();
        public int systemOverdueCount { get; set; }

        int m_SelectType;
        public int selectType
        {
            get { return m_SelectType; }
            set
            {
                if (m_SelectType != value)
                {
                    m_SelectType = value;
                    if (selectTypeRefresh != null)
                    {
                        selectTypeRefresh();
                    }
                }
            }
        }

        int m_SelectDateIndex;
        public int selectDateIndex
        {
            get { return m_SelectDateIndex; }
            set
            {
                if (m_SelectDateIndex != value)
                {
                    m_SelectDateIndex = value;
                    if (selectDateIndexRefresh != null)
                    {
                        selectDateIndexRefresh();
                    }
                }
            }
        }

        public int jumpType { get; set; }

        public bool autoOpen { get; set; }


        public bool IsOpen
        {
            get
            {
                return OperationTimeHepler.Instance.SatisfyOpenCondition(Operation.FestivalRedpack);
            }
        }

        public bool IsAdvance { get { return false; } }

        public bool priorityOpen { get { return redpoint.state == RedPointState.Simple; } }

        public int festivalDay
        {
            get
            {
                OperationFestivalRedpack operation;
                if (OperationTimeHepler.Instance.TryGetOperation(Operation.FestivalRedpack, out operation))
                {
                    return IsOpen ? operation.GetCurrentDay() : operation.totalDays;
                }
                return 0;
            }
        }

        public int operationDay
        {
            get
            {
                OperationFestivalRedpack operation;
                if (OperationTimeHepler.Instance.TryGetOperation(Operation.FestivalRedpack, out operation))
                {
                    return IsOpen ? operation.GetIndexOfTime() : operation.totalDays;
                }
                return 0;
            }
        }

        public int grabRedpackTimes { get; private set; }

        public int grabTotalJade { get; private set; }

        public float redpackVoiceInterval { get; private set; }

        DateTime voicePlayTime = DateTime.Now;

        public const int FESTIVALTASKREDPACKTYPE = 33;
        public const int FESTIVALSYSTEMREDPACK1 = 31;
        public const int FESTIVALSYSTEMREDPACK2 = 32;


        const int REDPOINTID = 20919;

        public readonly Redpoint redpoint = new Redpoint(MainRedDot.REDPOINT_OPENSERVER, REDPOINTID);
        public readonly Redpoint systemRedpoint = new Redpoint(REDPOINTID, 2091901);
        public readonly Redpoint taskRedpoint = new Redpoint(REDPOINTID, 2091902);
        public readonly Redpoint receiveRedpoint = new Redpoint(REDPOINTID, 2091903);
        public readonly Redpoint dailyRemindRedpoint = new Redpoint(REDPOINTID, 2091910);

        public event Action<int> onStateUpdate;
        public event Action redpackGrabRefresh;
        public event Action selectTypeRefresh;
        public event Action selectDateIndexRefresh;
        public event Action<int> achievementRefresh;
        public event Action taskRedpackRefresh;

        RedEnvelopeModel envelopeModel { get { return ModelCenter.Instance.GetModel<RedEnvelopeModel>(); } }
        AchievementModel achievementModel { get { return ModelCenter.Instance.GetModel<AchievementModel>(); } }

        public override void Init()
        {
            OperationTimeHepler.Instance.operationStartEvent += OperationStartEvent;
            OperationTimeHepler.Instance.operationEndEvent += OperationEndEvent;
            OperationTimeHepler.Instance.dayResetEvent += DayResetEvent;
            envelopeModel.EnvelopeUpdateEvent += EnvelopeUpdateEvent;
            envelopeModel.EnvelopeDelEvent += EnvelopeDelEvent;
            envelopeModel.EnvelopeGetEvent += EnvelopeGetEvent;
            achievementModel.achievementCompletedEvent += AchievementCompletedEvent;
            achievementModel.achievementProgressUpdateEvent += AchievementProgressUpdateEvent;
            ParseConfig();
            OpenServerActivityCenter.Instance.Register(19, this);
        }

        public void OnBeforePlayerDataInitialize()
        {
            grabRedpackTimes = 0;
            grabTotalJade = 0;
            serverInited = false;
        }

        public void OnPlayerLoginOk()
        {
            UpdateRedpoint();
            serverInited = true;
        }

        public override void UnInit()
        {
            OperationTimeHepler.Instance.operationStartEvent -= OperationStartEvent;
            OperationTimeHepler.Instance.operationEndEvent -= OperationEndEvent;
            OperationTimeHepler.Instance.dayResetEvent -= DayResetEvent;
            envelopeModel.EnvelopeUpdateEvent -= EnvelopeUpdateEvent;
            envelopeModel.EnvelopeDelEvent -= EnvelopeDelEvent;
            envelopeModel.EnvelopeGetEvent -= EnvelopeGetEvent;
            achievementModel.achievementCompletedEvent -= AchievementCompletedEvent;
            achievementModel.achievementProgressUpdateEvent -= AchievementProgressUpdateEvent;
        }

        void ParseConfig()
        {
            {
                var configs = FestivalRedpackTaskConfig.GetValues();
                foreach (var config in configs)
                {
                    List<FestivalRedpackAchievement> list;
                    if (!achievements.TryGetValue(config.FeastDay, out list))
                    {
                        list = new List<FestivalRedpackAchievement>();
                        achievements.Add(config.FeastDay, list);
                    }
                    list.Add(new FestivalRedpackAchievement()
                    {
                        id = config.ID,
                        achievements = config.achievements,
                    });
                }
            }

            {
                var configs = RedPackConfig.GetValues();
                foreach (var config in configs)
                {
                    if (config.RedEnvelopeType == FESTIVALSYSTEMREDPACK1
                        || config.RedEnvelopeType == FESTIVALSYSTEMREDPACK2)
                    {
                        var openTime = ParseTime(config.PacketOpenTime);
                        festivalRedpacks.Add(config.id, new FestivalRedpack()
                        {
                            id = config.id,
                            openTime = openTime,
                            endTime = openTime.AddTicks(config.ValidMinutes * TimeSpan.TicksPerMinute),
                            type = config.RedEnvelopeType,
                        });
                    }
                }
            }

            {
                var config = FuncConfigConfig.Get("RedEnvelopeVoiceCd");
                redpackVoiceInterval = float.Parse(config.Numerical1) / 1000;
            }
        }

        DateTime ParseTime(string timeString)
        {
            var year = 2018;
            var month = 1;
            var day = 1;
            var hour = 1;
            var minute = 20;
            var array = timeString.Split(' ');
            if (array != null && array.Length == 2)
            {
                var dateArray = array[0].Split('-');
                if (dateArray != null && dateArray.Length == 3)
                {
                    year = int.Parse(dateArray[0].Trim());
                    month = int.Parse(dateArray[1].Trim());
                    day = int.Parse(dateArray[2].Trim());
                }
                var timeArray = array[1].Split(':');
                if (timeArray != null && timeArray.Length == 2)
                {
                    hour = int.Parse(timeArray[0].Trim());
                    minute = int.Parse(timeArray[1].Trim());
                }
            }
            return new DateTime(year, month, day, hour, minute, 0);
        }

        public bool IsSystemRedpackOverdue(int id)
        {
            if (festivalRedpacks.ContainsKey(id))
            {
                return TimeUtility.ServerNow >= festivalRedpacks[id].endTime;
            }
            return false;
        }

        public bool IsExistSystemRedpack(int id, out int redpackId)
        {
            redpackId = 0;
            if (festivalRedpacks.ContainsKey(id))
            {
                List<int> redpacks = null;
                if (envelopeModel.TryGetEnvelopes(festivalRedpacks[id].type, out redpacks))
                {
                    foreach (var serverId in redpacks)
                    {
                        RedEnvelopeModel.RedEnvelope envelope;
                        if (envelopeModel.TryGetEnvelope(serverId, out envelope))
                        {
                            if (TimeUtility.GetTime(envelope.time).Equals(festivalRedpacks[id].openTime))
                            {
                                redpackId = serverId;
                                return true;
                            }
                        }
                    }
                }
            }
            return false;
        }

        public bool IsContainsAchievement(List<FestivalRedpackAchievement> list, int achievementId)
        {
            foreach (var festivalRedpackAchievement in list)
            {
                if (festivalRedpackAchievement.Contains(achievementId))
                {
                    return true;
                }
            }
            return false;
        }

        public bool TryGetRedpack(int id, out FestivalRedpack redpack)
        {
            return festivalRedpacks.TryGetValue(id, out redpack);
        }

        public bool TryGetAchievements(int index, out List<FestivalRedpackAchievement> list)
        {
            return achievements.TryGetValue(index, out list);
        }

        public int SystemRedpackSort(int lhs, int rhs)
        {
            bool lhsOverdue = IsSystemRedpackOverdue(lhs);
            bool rhsOverdue = IsSystemRedpackOverdue(rhs);
            var lhsServerId = 0;
            var rhsServerid = 0;
            IsExistSystemRedpack(lhs, out lhsServerId);
            IsExistSystemRedpack(rhs, out rhsServerid);
            RedEnvelopeModel.RedEnvelope lhsEnvelope;
            RedEnvelopeModel.RedEnvelope rhsEnvelope;
            var lhsState = 0;
            var rhsState = 0;
            if (envelopeModel.TryGetEnvelope(lhsServerId, out lhsEnvelope))
            {
                lhsState = lhsEnvelope.state;
            }
            if (envelopeModel.TryGetEnvelope(rhsServerid, out rhsEnvelope))
            {
                rhsState = rhsEnvelope.state;
            }

            bool lhsGrab = lhsState == 1 && !lhsOverdue;
            bool rhsGrab = rhsState == 1 && !rhsOverdue;
            if (lhsGrab != rhsGrab)
            {
                return -lhsGrab.CompareTo(rhsGrab);
            }

            bool lhsExist = lhsState == 0 && !lhsOverdue;
            bool rhsExist = rhsState == 0 && !rhsOverdue;
            if (lhsExist != rhsExist)
            {
                return -lhsExist.CompareTo(rhsExist);
            }

            bool lhsGot = lhsState == 2;
            bool rhsGot = rhsState == 2;
            if (lhsGot != rhsGot)
            {
                return -lhsGot.CompareTo(rhsGot);
            }

            bool lhsDone = lhsState == 3;
            bool rhsDone = rhsState == 3;
            if (lhsDone != rhsDone)
            {
                return -lhsDone.CompareTo(rhsDone);
            }

            if (lhsOverdue != rhsOverdue)
            {
                return lhsOverdue.CompareTo(rhsOverdue);
            }

            if (festivalRedpacks.ContainsKey(lhs)
                && festivalRedpacks.ContainsKey(rhs))
            {
                return festivalRedpacks[lhs].openTime.CompareTo(festivalRedpacks[rhs].openTime);
            }
            return 0;
        }

        public int AchievementSort(FestivalRedpackAchievement lhs, FestivalRedpackAchievement rhs)
        {
            Achievement lhsAchievement;
            Achievement rhsAchievement;
            if (achievementModel.TryGetAchievement(lhs.CurrentAchieve, out lhsAchievement)
                && achievementModel.TryGetAchievement(rhs.CurrentAchieve, out rhsAchievement))
            {
                if (lhsAchievement.completed.CompareTo(rhsAchievement.completed) != 0)
                {
                    return lhsAchievement.completed.CompareTo(rhsAchievement.completed);
                }
                bool xReach = Achievement.IsReach(lhsAchievement.id, lhsAchievement.progress);
                bool yReach = Achievement.IsReach(rhsAchievement.id, rhsAchievement.progress);
                if (xReach.CompareTo(yReach) != 0)
                {
                    return -xReach.CompareTo(yReach);
                }
            }
            return lhs.id.CompareTo(rhs.id);
        }

        public int CompareEnvelope(int x, int y)
        {
            RedEnvelopeModel.RedEnvelope xEnvelope;
            RedEnvelopeModel.RedEnvelope yEnvelope;
            if (envelopeModel.TryGetEnvelope(x, out xEnvelope)
                && envelopeModel.TryGetEnvelope(y, out yEnvelope))
            {
                if (xEnvelope.state.CompareTo(yEnvelope.state) != 0)
                {
                    return xEnvelope.state.CompareTo(yEnvelope.state);
                }
                return -xEnvelope.time.CompareTo(yEnvelope.time);
            }
            return -x.CompareTo(y);
        }

        public void OnReceivePackage(HAB25_tagMCFeastRedPackInfo package)
        {
            grabRedpackTimes = package.GrabCnt;
            grabTotalJade = (int)package.MoneyNum;
            if (redpackGrabRefresh != null)
            {
                redpackGrabRefresh();
            }
            UpdateRedpoint();
        }

        private void DayResetEvent(int resetType)
        {
            OperationBase operationBase;
            if (OperationTimeHepler.Instance.TryGetOperationTime(Operation.FestivalRedpack, out operationBase))
            {
                if (resetType == operationBase.resetType)
                {
                    UpdateRedpoint();
                }
            }
        }

        private void OperationEndEvent(Operation type, int state)
        {
            if (type == Operation.FestivalRedpack && state == 0)
            {
                UpdateRedpoint();
                if (onStateUpdate != null)
                {
                    onStateUpdate(19);
                }
            }
        }

        private void OperationStartEvent(Operation type, int state)
        {
            if (type == Operation.FestivalRedpack && state == 0)
            {
                UpdateRedpoint();
                if (onStateUpdate != null)
                {
                    onStateUpdate(19);
                }
            }
        }

        private void EnvelopeUpdateEvent()
        {
            bool rewardable = receiveRedpoint.state == RedPointState.GetReward;

            UpdateRedpoint();
            if (taskRedpackRefresh != null)
            {
                taskRedpackRefresh();
            }

            if (!rewardable && receiveRedpoint.state == RedPointState.GetReward
                && serverInited && !ExistSelfTaskRedpack())
            {
                PlayRedpackVoice();
            }
        }

        public bool ExistSelfTaskRedpack()
        {
            List<int> list;
            if (envelopeModel.TryGetEnvelopes(FESTIVALTASKREDPACKTYPE, out list))
            {
                foreach (var id in list)
                {
                    RedEnvelopeModel.RedEnvelope envelope;
                    if (envelopeModel.TryGetEnvelope(id, out envelope))
                    {
                        if (envelope.player == PlayerDatas.Instance.PlayerId
                            && envelope.state == 1)
                        {
                            return true;
                        }
                    }
                }
            }
            return false;
        }

        public void JudgePlayRedpackVoice(int type)
        {
            if (type == FESTIVALSYSTEMREDPACK1
                || type == FESTIVALSYSTEMREDPACK2)
            {
                PlayRedpackVoice();
            }
        }

        void PlayRedpackVoice()
        {
            if ((DateTime.Now - voicePlayTime).TotalSeconds < redpackVoiceInterval)
            {
                return;
            }
            SoundPlayer.Instance.PlayUIAudio(632);
            voicePlayTime = DateTime.Now;
        }

        private void EnvelopeDelEvent()
        {
            UpdateRedpoint();
            if (taskRedpackRefresh != null)
            {
                taskRedpackRefresh();
            }
        }

        private void EnvelopeGetEvent(int _id)
        {
            if (!serverInited)
            {
                return;
            }
            RedEnvelopeModel.RedEnvelope _envelope;
            if (envelopeModel.TryGetEnvelope(_id, out _envelope))
            {
                if (_envelope.player == PlayerDatas.Instance.PlayerId &&
                    _envelope.type == FESTIVALTASKREDPACKTYPE
                    && _envelope.state == 1)
                {
                    envelopeModel.cacheEnvelopeId = _envelope.id;
                    envelopeModel.envelopeSfx = _envelope.id;
                    CAB12_tagCMGrabFamilyRedPacket _pak = new CAB12_tagCMGrabFamilyRedPacket();
                    _pak.RedPaketID = (uint)_envelope.id;
                    _pak.GetWay = FESTIVALTASKREDPACKTYPE;
                    GameNetSystem.Instance.SendInfo(_pak);
                }
            }
        }

        private void AchievementCompletedEvent(int _achieve)
        {
            List<FestivalRedpackAchievement> list;
            if (TryGetAchievements(operationDay + 1, out list) && IsContainsAchievement(list, _achieve))
            {
                if (achievementRefresh != null)
                {
                    achievementRefresh(_achieve);
                }
                UpdateRedpoint();
            }
        }

        private void AchievementProgressUpdateEvent(int _achieve)
        {
            List<FestivalRedpackAchievement> list;
            if (TryGetAchievements(operationDay + 1, out list) && IsContainsAchievement(list, _achieve))
            {
                if (achievementRefresh != null)
                {
                    achievementRefresh(_achieve);
                }
                UpdateRedpoint();
            }
        }

        public bool ExistRewardableRedpack()
        {
            UpdateRedpoint();
            return redpoint.state == RedPointState.GetReward;
        }

        public void SetDayRemind()
        {
            DayRemind.Instance.SetDayRemind(DayRemind.FESTIVALREDPACKREMIND, true);
            UpdateRedpoint();
        }

        private void UpdateRedpoint()
        {
            var existSystemRedpack = false;
            var existFinishTask = false;
            var existUnGetRedpack = false;
            var dailyRemind = false;
            if (IsOpen)
            {
                OperationFestivalRedpack operation;
                if (OperationTimeHepler.Instance.TryGetOperation(Operation.FestivalRedpack, out operation))
                {
                    var index = festivalDay;
                    var systemRedpacks = index < operation.redpacks.Count && index >= 0 ?
                        operation.redpacks[index].redpacks : operation.redpacks[0].redpacks;
                    foreach (var redpackId in systemRedpacks)
                    {
                        if (IsSystemRedpackOverdue(redpackId))
                        {
                            continue;
                        }
                        var redpackServerId = 0;
                        if (IsExistSystemRedpack(redpackId, out redpackServerId))
                        {
                            RedEnvelopeModel.RedEnvelope envelope;
                            if (envelopeModel.TryGetEnvelope(redpackServerId, out envelope))
                            {
                                if (envelope.state == 1)
                                {
                                    existSystemRedpack = true;
                                    break;
                                }
                            }
                        }
                    }
                }

                List<FestivalRedpackAchievement> list;
                if (TryGetAchievements(operationDay + 1, out list))
                {
                    foreach (var festivalRedpackAchievement in list)
                    {
                        Achievement achievement;
                        if (achievementModel.TryGetAchievement(festivalRedpackAchievement.CurrentAchieve, out achievement))
                        {
                            if (Achievement.IsReach(festivalRedpackAchievement.CurrentAchieve, achievement.progress) && !achievement.completed)
                            {
                                existFinishTask = true;
                                break;
                            }
                        }
                    }
                }

                envelopeModel.GetEnvelopes(FESTIVALTASKREDPACKTYPE, ref taskRedpacks);
                foreach (var id in taskRedpacks)
                {
                    RedEnvelopeModel.RedEnvelope envelope;
                    if (envelopeModel.TryGetEnvelope(id, out envelope))
                    {
                        if (envelope.player == PlayerDatas.Instance.baseData.PlayerID)
                        {
                            if (envelope.state == 1)
                            {
                                existUnGetRedpack = true;
                                break;
                            }
                        }
                        else
                        {
                            if (envelope.state == 1 && grabRedpackTimes > 0)
                            {
                                existUnGetRedpack = true;
                                break;
                            }
                        }
                    }
                }

                if (!DayRemind.Instance.GetDayRemind(DayRemind.FESTIVALREDPACKREMIND))
                {
                    dailyRemind = true;
                }
            }
            systemRedpoint.state = existSystemRedpack ? RedPointState.GetReward : RedPointState.None;
            taskRedpoint.state = existFinishTask ? RedPointState.Simple : RedPointState.None;
            receiveRedpoint.state = existUnGetRedpack ? RedPointState.GetReward : RedPointState.None;
            dailyRemindRedpoint.state = dailyRemind ? RedPointState.Simple : RedPointState.None;
        }
    }

    public class FestivalRedpackAchievement
    {
        public int id;
        public int[] achievements;

        public AchievementModel model { get { return ModelCenter.Instance.GetModel<AchievementModel>(); } }

        public int CurrentAchieve
        {
            get
            {
                for (int i = 0; i < achievements.Length; i++)
                {
                    Achievement achievement;
                    if (model.TryGetAchievement(achievements[i], out achievement))
                    {
                        if (!achievement.completed)
                        {
                            return achievements[i];
                        }
                    }
                }
                return achievements[achievements.Length - 1];
            }
        }

        public bool Contains(int _achieve)
        {
            for (int i = 0; i < achievements.Length; i++)
            {
                if (achievements[i] == _achieve)
                {
                    return true;
                }
            }
            return false;
        }
    }

    public struct FestivalRedpack
    {
        public int id;
        public int type;
        public DateTime openTime;
        public DateTime endTime;
    }

    public enum FestivalRedpackTaskState
    {
        Doing,
        ReceiveReward,
        Completed,
    }
}