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

using UnityEngine;
namespace vnxbqy.UI
{
    
	public class OSTimeLimitGiftModel : Model, IPlayerLoginOk, IBeforePlayerDataInitialize, IOpenServerActivity
    {
        Dictionary<int, List<StoreConfig>> m_OSTimeLimitGifts = new Dictionary<int, List<StoreConfig>>();

        private DateTime m_OverdueTime = DateTime.Now;
        public DateTime overdueTime { get { return m_OverdueTime; } }
        public int openDays { get; private set; }

        public Redpoint redpoint { get; private set; }

        StoreModel m_StoreModel;

        public event Action<int> onStateUpdate;

        StoreModel storeModel
        {
            get
            {
                return m_StoreModel ?? (m_StoreModel = ModelCenter.Instance.GetModel<StoreModel>());
            }
        }

        public bool IsOpen
        {
            get
            {
                return currentDay <= openDays && FuncOpen.Instance.IsFuncOpen(132);
            }
        }

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

        public int currentDay
        {
            get
            {
                return TimeUtility.OpenDay + 1;
            }
        }

        public bool IsAdvance
        {
            get
            {
                return false;
            }
        }

        public override void Init()
        {
            var _openDay = 0;
            List<StoreConfig> _list = null;
            StoreConfig.TryGetStoreConfigs((int)StoreFunc.OSTimeLimitGift, out _list);
            if (_list != null)
            {
                for (int i = 0; i < _list.Count; i++)
                {
                    List<StoreConfig> _configs = null;
                    if (!m_OSTimeLimitGifts.TryGetValue(_list[i].LimitValue, out _configs))
                    {
                        _configs = new List<StoreConfig>();
                        m_OSTimeLimitGifts.Add(_list[i].LimitValue, _configs);
                    }
                    _configs.Add(_list[i]);
                    if (_list[i].LimitValue > _openDay)
                    {
                        _openDay = _list[i].LimitValue;
                    }
                }
            }
            openDays = _openDay;

            redpoint = new Redpoint(MainRedDot.REDPOINT_OPENSERVER, MainRedDot.REDPOINT_OPENSERVER * 100 + 3);

            TimeUtility.OnServerOpenDayRefresh += OnServerOpenDayRefresh;
            storeModel.RefreshBuyShopLimitEvent += UpdateRedpoint;
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
            OpenServerActivityCenter.Instance.Register(3, this);
        }

        private void OnServerOpenDayRefresh()
        {
            OnCreateRoleTimeRefresh();
        }

        public override void UnInit()
        {
            TimeUtility.OnServerOpenDayRefresh -= OnServerOpenDayRefresh;
            storeModel.RefreshBuyShopLimitEvent -= UpdateRedpoint;
            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
        }

        public void OnBeforePlayerDataInitialize()
        {

        }

        public void OnPlayerLoginOk()
        {
            UpdateRedpoint();
        }

        private void OnCreateRoleTimeRefresh()
        {
            if (currentDay <= openDays)
            {
                m_OverdueTime = TimeUtility.ServerNow.AddDays(openDays - currentDay + 1);
                m_OverdueTime = new DateTime(m_OverdueTime.Year, m_OverdueTime.Month, m_OverdueTime.Day);
            }
            UpdateRedpoint();
        }

        private void OnFuncStateChangeEvent(int _id)
        {
            if (_id == 132)
            {
                UpdateRedpoint();
                if (onStateUpdate != null)
                {
                    onStateUpdate(3);
                }
            }
        }

        public bool TryGetGifts(int _day,out List<StoreConfig> _list)
        {
            return m_OSTimeLimitGifts.TryGetValue(_day, out _list);
        }

        public void SetDayRemind()
        {
            if (redpoint.state == RedPointState.Simple)
            {
                DayRemind.Instance.SetDayRemind(DayRemind.OSTIMEGIFT_REDPOINT, true);
                UpdateRedpoint();
            }
        }

        void UpdateRedpoint()
        {
            redpoint.state = RedPointState.None;
            if (currentDay > openDays || !FuncOpen.Instance.IsFuncOpen(132)
                || DayRemind.Instance.GetDayRemind(DayRemind.OSTIMEGIFT_REDPOINT))
            {
                return;
            }
            List<StoreConfig> _list;
            var day = Mathf.Max(1, currentDay);
            day = Mathf.Min(day, openDays);
            if (TryGetGifts(day, out _list))
            {
                for (int i = 0; i < _list.Count; i++)
                {
                    var _limit = storeModel.GetBuyShopLimit((uint)_list[i].ID);
                    if (_limit == null || _limit.BuyCnt < _list[i].GoumaiNumber[0])
                    {
                        redpoint.state = RedPointState.Simple;
                        break;
                    }
                }
            }
        }
    }
}