using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace Snxxz.UI
{
    public class ConsumeRebateModel : Model, IPlayerLoginOk, IBeforePlayerDataInitialize, IOpenServerActivity
    {
        public event Action consumeRebateUpdateEvent;
        public event Action<int> onStateUpate;

        public override void Init()
        {
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent += PlayerDataRefreshInfoEvent;
            OperationTimeHepler.Instance.operationStartEvent += OperationStartEvent;
            OperationTimeHepler.Instance.operationEndEvent += OperationEndEvent;
            GlobalTimeEvent.Instance.secondEvent += SecondEvent;
            OpenServerActivityCenter.Instance.Register(1, this);
        }

        public void OnBeforePlayerDataInitialize()
        {
            costTotal = 0;
        }

        public void OnPlayerLoginOk()
        {
            UpdateRedpoint();
            rebateOpenDayIndex = OperationTimeHepler.Instance.IndexOfOperationDays(Operation.ConsumeRebate);
        }

        public override void UnInit()
        {
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent -= PlayerDataRefreshInfoEvent;
            OperationTimeHepler.Instance.operationStartEvent -= OperationStartEvent;
            OperationTimeHepler.Instance.operationEndEvent -= OperationEndEvent;
            GlobalTimeEvent.Instance.secondEvent -= SecondEvent;
        }

        public bool IsOpen
        {
            get
            {
                OperationBase operation;
                OperationTimeHepler.Instance.TryGetOperationTime(Operation.ConsumeRebate, out operation);
                return operation != null && operation.InTime(TimeUtility.ServerNow) && operation.SatisfyOpenCondition();
            }
        }

        public int displayIndex { get; set; }

        public int costTotal { get; private set; }

        private uint consumeGotRecord { get; set; }

        public bool priorityOpen
        {
            get
            {
                return consumeRebateRedpoint.state == RedPointState.GetReward;
            }
        }

        int rebateOpenDayIndex = -1;

        public bool IsRebateGot(int day, int _index)
        {
            OperationBase operationBase;
            if (OperationTimeHepler.Instance.TryGetOperationTime(Operation.ConsumeRebate, out operationBase))
            {
                OperationConsumeRebate operation = operationBase as OperationConsumeRebate;
                if (day >= 0 && day < operation.rebates.Count)
                {
                    var rebate = operation.rebates[day];
                    if (_index >= 0 && _index < rebate.rebateGrades.Count)
                    {
                        return IsRebateGot(rebate.rebateGrades[_index].index);
                    }
                }
            }
            return false;
        }

        private void PlayerDataRefreshInfoEvent(PlayerDataRefresh refreshType)
        {
            if (refreshType == PlayerDataRefresh.LV)
            {
                UpdateRedpoint();
            }
        }

        private void SecondEvent()
        {
            var index = OperationTimeHepler.Instance.IndexOfOperationDays(Operation.ConsumeRebate);
            if (index != rebateOpenDayIndex)
            {
                rebateOpenDayIndex = index;
                UpdateRedpoint();
            }
        }

        private void OperationStartEvent(Operation type, int state)
        {
            if (type == Operation.ConsumeRebate && state == 0)
            {
                UpdateRedpoint();
                if (onStateUpate != null)
                {
                    onStateUpate(1);
                }
            }
        }

        private void OperationEndEvent(Operation type, int state)
        {
            if (type == Operation.ConsumeRebate && state == 0)
            {
                UpdateRedpoint();
                if (onStateUpate != null)
                {
                    onStateUpate(1);
                }
            }
        }

        bool IsRebateGot(int _index)
        {
            return (consumeGotRecord & (1 << _index)) != 0;
        }

        public void GotConsumeRebate(int _day, int _index)
        {
            OperationBase operationBase;
            if (!OperationTimeHepler.Instance.InOperationTime(Operation.ConsumeRebate))
            {
                SysNotifyMgr.Instance.ShowTip("ActiveOutTime");
                return;
            }
            if (OperationTimeHepler.Instance.TryGetOperationTime(Operation.ConsumeRebate, out operationBase))
            {
                OperationConsumeRebate operation = operationBase as OperationConsumeRebate;
                if (_day >= 0 && _day < operation.rebates.Count)
                {
                    var rebate = operation.rebates[_day];
                    if (_index >= 0 && _index < rebate.rebateGrades.Count)
                    {
                        if (IsRebateGot(rebate.rebateGrades[_index].index))
                        {
                            SysNotifyMgr.Instance.ShowTip("ConsumeRebateGot");
                            return;
                        }
                        else if (costTotal < rebate.rebateGrades[_index].needGold)
                        {
                            SysNotifyMgr.Instance.ShowTip("ConsumeRebateNoSatisfy");
                            return;
                        }
                        CA504_tagCMPlayerGetReward pak = new CA504_tagCMPlayerGetReward();
                        pak.RewardType = (byte)GotServerRewardType.Def_RewardType_ConsumeRebate;
                        pak.DataEx = (uint)_index;
                        pak.DataExStrLen = 0;
                        pak.DataExStr = string.Empty;
                        GameNetSystem.Instance.SendInfo(pak);
                    }
                }
            }
        }

        public void UpdateConsumeRebate(HAA10_tagMCCostRebatePlayerInfo package)
        {
            costTotal = (int)package.CostGoldTotal;
            consumeGotRecord = package.AwardRecord;
            if (consumeRebateUpdateEvent != null)
            {
                consumeRebateUpdateEvent();
            }
            UpdateRedpoint();
        }

        public int GetTotalConsume()
        {
            return costTotal;
        }

        public Redpoint consumeRebateRedpoint = new Redpoint(MainRedDot.REDPOINT_OPENSERVER, 20901);
        private void UpdateRedpoint()
        {
            consumeRebateRedpoint.state = RedPointState.None;
            if (!IsOpen)
            {
                return;
            }
            rebateOpenDayIndex = OperationTimeHepler.Instance.IndexOfOperationDays(Operation.ConsumeRebate);
            OperationBase operationBase;
            if (OperationTimeHepler.Instance.TryGetOperationTime(Operation.ConsumeRebate, out operationBase))
            {
                OperationConsumeRebate operation = operationBase as OperationConsumeRebate;
                var rebate = operation.GetRebate(TimeUtility.ServerNow);
                if (rebate != null)
                {
                    for (int i = 0; i < rebate.rebateGrades.Count; i++)
                    {
                        var rebateGrade = rebate.rebateGrades[i];
                        if (IsRebateGot(rebateGrade.index))
                        {
                            continue;
                        }
                        else if (costTotal < rebateGrade.needGold)
                        {
                            continue;
                        }
                        consumeRebateRedpoint.state = RedPointState.GetReward;
                        break;
                    }
                }
            }
        }
    }
}