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

namespace Snxxz.UI
{
    [XLua.LuaCallCSharp]
	public class OSRedEnvelopeModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk, IOpenServerActivity
    {
        AchievementModel m_AchievementModel;
        AchievementModel achieveModel
        {
            get
            {
                return m_AchievementModel ?? (m_AchievementModel = ModelCenter.Instance.GetModel<AchievementModel>());
            }
        }

        RedEnvelopeModel m_RedEnvelopeModel;
        RedEnvelopeModel envelopeModel
        {
            get
            {
                return m_RedEnvelopeModel ?? (m_RedEnvelopeModel = ModelCenter.Instance.GetModel<RedEnvelopeModel>());
            }
        }

        bool servereInited = false;

        public override void Init()
        {
            ParseConfig();
            achieveModel.achievementCompletedEvent += AchievementCompletedEvent;
            achieveModel.achievementProgressUpdateEvent += AchievementProgressUpdateEvent;
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
            TimeUtility.OnServerOpenDayRefresh += OnServerOpenDayRefresh;
            envelopeModel.EnvelopeUpdateEvent += EnvelopeUpdateEvent;
            envelopeModel.EnvelopeDelEvent += EnvelopeUpdateEvent;
            envelopeModel.EnvelopeGetEvent += EnvelopeGetEvent;
            OpenServerActivityCenter.Instance.Register(2, this);
        }

        public override void UnInit()
        {

        }

        public void OnBeforePlayerDataInitialize()
        {
            servereInited = false;
        }

        private void OnFuncStateChangeEvent(int func)
        {
            if (m_AllFuncs.Contains(func))
            {
                UpdateAchieveRedpoint();
            }
            if (func == (int)FuncOpenEnum.OpenServerRedEnvelope)
            {
                UpdateRedpackRedpoint();
                UpdateAchieveRedpoint();
                if (OSRedEnvelopeUpdateEvent != null)
                {
                    OSRedEnvelopeUpdateEvent();
                }
                if (onStateUpate != null)
                {
                    onStateUpate(2);
                }
            }
        }

        private void OnServerOpenDayRefresh()
        {
            UpdateAchieveRedpoint();
            UpdateRedpackRedpoint();
        }

        public event Action FuncChangeEvent;
        private int m_SelectType = 1;
        public int selectType
        {
            get { return m_SelectType; }
            set
            {
                m_SelectType = value;
                ModelCenter.Instance.GetModel<RedPacketModel>().RedBagId = 0;
                if (FuncChangeEvent != null)
                {
                    FuncChangeEvent();
                }
            }
        }

        public int JumpType { get; set; }
        public bool autoOpen { get; set; }

        #region 配置
        public List<int> m_OSRedAchieves { get; private set; }
        public Dictionary<int, OSRedAchieve> m_OSRedAchieveDict { get; private set; }
        private List<int> m_AllAchieves = new List<int>();
        public List<int> m_AllFuncs { get; private set; }
        public int openDays { get; private set; }
        public int OSRedEnvelopeType { get; private set; }
        public float envelopeVoiceCD { get; private set; }
        public int addCounts { get; private set; }
        public DateTime overTime = DateTime.Now;
        void ParseConfig()
        {
            var _allCfgs = OSRedAchieveConfig.GetValues();
            m_OSRedAchieveDict = new Dictionary<int, OSRedAchieve>();
            m_OSRedAchieves = new List<int>();
            m_AllFuncs = new List<int>();
            for (int i = 0; i < _allCfgs.Count; i++)
            {
                for (int k = 0; k < _allCfgs[i].Achieves.Length; k++)
                {
                    m_AllAchieves.Add(_allCfgs[i].Achieves[k]);
                }
                m_OSRedAchieveDict.Add(_allCfgs[i].id, new OSRedAchieve()
                {
                    id = _allCfgs[i].id,
                    achieves = _allCfgs[i].Achieves
                });
                m_OSRedAchieves.Add(_allCfgs[i].id);
                if (!m_AllFuncs.Contains(_allCfgs[i].func))
                {
                    m_AllFuncs.Add(_allCfgs[i].func);
                }
            }

            var _cfg = FuncConfigConfig.Get("OpenServerRedPacketCfg");
            openDays = int.Parse(_cfg.Numerical1);
            addCounts = int.Parse(_cfg.Numerical5);
            _cfg = FuncConfigConfig.Get("OpenServerRedPacketType");
            OSRedEnvelopeType = int.Parse(_cfg.Numerical1);
            _cfg = FuncConfigConfig.Get("RedEnvelopeVoiceCd");
            envelopeVoiceCD = float.Parse(_cfg.Numerical1) / 1000;
        }

        public class OSRedAchieve
        {
            public int id;

            public int[] achieves;

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

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

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

        #region 红点
        private Redpoint m_OpenServerRedPackRedpoint = new Redpoint(MainRedDot.REDPOINT_OPENSERVER, 20902);
        public Redpoint m_RedAchieveRedpoint = new Redpoint(20902, 2090201);
        public Redpoint m_OpenServerGetRedpin = new Redpoint(20902, 2090202);
        public void UpdateAchieveRedpoint()
        {
            m_RedAchieveRedpoint.state = RedPointState.None;
            if (TimeUtility.OpenDay >= openDays)
            {
                return;
            }
            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.OpenServerRedEnvelope))
            {
                return;
            }
            foreach (var _achieve in m_OSRedAchieveDict.Values)
            {
                var _cfg = OSRedAchieveConfig.Get(_achieve.id);
                if (_cfg.func != 0 && FuncOpen.Instance.IsFuncOpen(_cfg.func))
                {
                    continue;
                }
                var _id = _achieve.CurrentAchieve;
                Achievement achievement;
                if (achieveModel.TryGetAchievement(_id, out achievement))
                {
                    if (Achievement.IsReach(_id, achievement.progress) && !achievement.completed)
                    {
                        m_RedAchieveRedpoint.state = RedPointState.Simple;
                        break;
                    }
                }
            }
        }

        public void UpdateRedpackRedpoint(bool _checkVoice = false)
        {
            bool hasRed = m_OpenServerGetRedpin.state == RedPointState.GetReward;
            m_OpenServerGetRedpin.state = RedPointState.None;
            if (CanGetEnvelope())
            {
                m_OpenServerGetRedpin.state = RedPointState.GetReward;
                if (_checkVoice && !hasRed && servereInited && HasOtherRedpack() && !HasSelfRedpack())
                {
                    CheckRedEnvelopeVoice();
                }
            }
        }

        DateTime beforePlayTime = DateTime.Now;
        private void CheckRedEnvelopeVoice()
        {
            if ((DateTime.Now - beforePlayTime).TotalSeconds < envelopeVoiceCD)
            {
                return;
            }
            SoundPlayer.Instance.PlayUIAudio(632);
            beforePlayTime = DateTime.Now;
        }
        #endregion

        public void OnPlayerLoginOk()
        {
            UpdateAchieveRedpoint();
            if (TimeUtility.OpenDay < openDays)
            {
                overTime = TimeUtility.ServerNow.AddDays(openDays - TimeUtility.OpenDay);
                DateTime.TryParse(overTime.ToString("yyyy-MM-dd"), out overTime);
            }
            EnvelopeUpdateEvent();
            servereInited = true;
        }

        public event Action<int> OSRedAchieveUpdateEvent;
        private void AchievementCompletedEvent(int _achieve)
        {
            if (!m_AllAchieves.Contains(_achieve))
            {
                return;
            }
            OSRedAchieve _redAchieve;
            m_OSRedAchieves.Sort(CompareAchievement);
            if (TryGetOSRedAchieve(_achieve, out _redAchieve))
            {
                if (OSRedAchieveUpdateEvent != null)
                {
                    OSRedAchieveUpdateEvent(_redAchieve.id);
                }
            }
            UpdateAchieveRedpoint();
        }

        public bool TryGetOSRedAchieve(int _achieve, out OSRedAchieve _osRedAchieve)
        {
            _osRedAchieve = null;
            foreach (var _redAchieve in m_OSRedAchieveDict.Values)
            {
                if (_redAchieve.CurrentAchieve == _achieve)
                {
                    _osRedAchieve = _redAchieve;
                    return true;
                }
            }
            return false;
        }

        private void AchievementProgressUpdateEvent(int _achieve)
        {
            if (!m_AllAchieves.Contains(_achieve))
            {
                return;
            }
            OSRedAchieve _redAchieve;
            if (TryGetOSRedAchieve(_achieve, out _redAchieve))
            {
                if (OSRedAchieveUpdateEvent != null)
                {
                    OSRedAchieveUpdateEvent(_redAchieve.id);
                }
            }
            UpdateAchieveRedpoint();
        }

        public List<int> m_OSRedEnvelopes = new List<int>();
        public event Action OSRedEnvelopeUpdateEvent;
        private void EnvelopeUpdateEvent()
        {
            envelopeModel.GetEnvelopes(OSRedEnvelopeType, ref m_OSRedEnvelopes);
            m_OSRedEnvelopes.Sort(CompareEnvelope);
            if (OSRedEnvelopeUpdateEvent != null)
            {
                OSRedEnvelopeUpdateEvent();
            }
            UpdateRedpackRedpoint(true);
        }

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

        public bool CanGetEnvelope()
        {
            if (TimeUtility.OpenDay >= openDays)
            {
                return false;
            }
            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.OpenServerRedEnvelope))
            {
                return false;
            }
            if (HasSelfRedpack())
            {
                return true;
            }
            if (getEnvelopeTimes <= 0)
            {
                return false;
            }
            for (int i = 0; i < m_OSRedEnvelopes.Count; i++)
            {
                RedEnvelopeModel.RedEnvelope _envelope;
                if (envelopeModel.TryGetEnvelope(m_OSRedEnvelopes[i], out _envelope))
                {
                    if (_envelope.state == 1)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        public bool HasSelfRedpack()
        {
            for (int i = 0; i < m_OSRedEnvelopes.Count; i++)
            {
                RedEnvelopeModel.RedEnvelope _envelope;
                if (envelopeModel.TryGetEnvelope(m_OSRedEnvelopes[i], out _envelope))
                {
                    if (_envelope.state == 1 && _envelope.player == PlayerDatas.Instance.PlayerId)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        public bool HasOtherRedpack()
        {
            for (int i = 0; i < m_OSRedEnvelopes.Count; i++)
            {
                RedEnvelopeModel.RedEnvelope _envelope;
                if (envelopeModel.TryGetEnvelope(m_OSRedEnvelopes[i], out _envelope))
                {
                    if (_envelope.state == 1 && _envelope.player != PlayerDatas.Instance.PlayerId)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        public int totalJadeGet { get; private set; }
        public int getEnvelopeTimes { get; private set; }

        public bool IsOpen
        {
            get
            {
                return TimeUtility.OpenDay < openDays && FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.OpenServerRedEnvelope);
            }
        }

        public bool priorityOpen
        {
            get
            {
                return m_RedAchieveRedpoint.state == RedPointState.Simple
                    || m_OpenServerGetRedpin.state == RedPointState.GetReward;
            }
        }

        public bool IsAdvance
        {
            get
            {
                return false;
            }
        }

        public event Action OSRedEnvelopeInfoEnvent;
        public event Action<int> onStateUpate;

        public void UpdateOSRedEnvelope(HAB24_tagMCOpenServerRedPacketInfo _pak)
        {
            totalJadeGet = (int)_pak.MoneyNum;
            getEnvelopeTimes = _pak.GrabCnt;
            if (OSRedEnvelopeInfoEnvent != null)
            {
                OSRedEnvelopeInfoEnvent();
            }
            UpdateRedpackRedpoint();
        }

        public int cacheAchievement = 0;
        public void RequestSendAchieveEnvelope(int _id)
        {
            if (!WindowCenter.Instance.IsOpen<OSRedEnvelopeSendWin>())
            {
                OSRedEnvelopeSendWin.achievementId = _id;
                WindowCenter.Instance.Open<OSRedEnvelopeSendWin>();
            }
        }

        public int CompareAchievement(int x, int y)
        {
            OSRedAchieve xRedAchieve;
            OSRedAchieve yRedAchieve;
            if (m_OSRedAchieveDict.TryGetValue(x, out xRedAchieve)
                && m_OSRedAchieveDict.TryGetValue(y, out yRedAchieve))
            {
                Achievement xAchievement;
                Achievement yAchievement;
                if (achieveModel.TryGetAchievement(xRedAchieve.CurrentAchieve, out xAchievement)
                    && achieveModel.TryGetAchievement(yRedAchieve.CurrentAchieve, out yAchievement))
                {
                    if (xAchievement.completed.CompareTo(yAchievement.completed) != 0)
                    {
                        return xAchievement.completed.CompareTo(yAchievement.completed);
                    }
                    bool xReach = Achievement.IsReach(xAchievement.id, xAchievement.progress);
                    bool yReach = Achievement.IsReach(yAchievement.id, yAchievement.progress);
                    if (xReach.CompareTo(yReach) != 0)
                    {
                        return -xReach.CompareTo(yReach);
                    }
                }
            }
            return x.CompareTo(y);
        }

        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);
        }
    }
}