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


namespace vnxbqy.UI
{
    
	public class BossRebornModel : Model, IOpenServerActivity
    {
        int m_BossRebornIntegral = 0;
        public int bossRebornIntegral {
            get { return m_BossRebornIntegral; }
            set {
                if (m_BossRebornIntegral != value)
                {
                    m_BossRebornIntegral = value;
                    if (bossRebornIntergralEvent != null)
                    {
                        bossRebornIntergralEvent();
                    }
                }
            }
        }

        int m_BossRebornInderalTotal = 0;
        public int bossRebornIndegralTotal {
            get { return m_BossRebornInderalTotal; }
            set { m_BossRebornInderalTotal = value; }
        }

        int m_BossRebornCount = -1;
        public int bossRebornCount {
            get { return m_BossRebornCount; }
            set {
                if (m_BossRebornCount != value)
                {
                    m_BossRebornCount = value;
                    if (bossRebornCountEvent != null)
                    {
                        bossRebornCountEvent();
                    }
                }
            }
        }

        public int bossRebornFullCnt = 0;

        public int surplusSecond { get { return OperationTimeHepler.Instance.GetOperationSurplusTime(Operation.BossReborn); } }

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

        public event Action bossRebornIntergralEvent;
        public event Action bossRebornCountEvent;
        public event Action<int> bossTaskStateChangeEvent;
        public event Action<int> onStateUpdate;

        Dictionary<int, BossRebornTask> bossRebornTasks = new Dictionary<int, BossRebornTask>();

        const int bossRebornPointId = 20909;
        public Redpoint bossRebornPoint = new Redpoint(MainRedDot.REDPOINT_OPENSERVER, bossRebornPointId);

        public int MWBossID = 0;

        public override void Init()
        {
            OperationTimeHepler.Instance.operationStartEvent += OperationStartEvent;
            OperationTimeHepler.Instance.operationEndEvent += OperationEndEvent;
            OpenServerActivityCenter.Instance.Register(9, this);
            MWBossID = int.Parse(FuncConfigConfig.Get("BossRebornServerBoss").Numerical3);
        }

        public override void UnInit()
        {
            OperationTimeHepler.Instance.operationStartEvent -= OperationStartEvent;
            OperationTimeHepler.Instance.operationEndEvent -= OperationEndEvent;
        }

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

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

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

        public bool IsAdvance
        {
            get
            {
                return OperationTimeHepler.Instance.SatisfyAdvanceCondition(Operation.BossReborn);
            }
        }

        public void UpdateTaskBaseInfos(HAB04_tagMCBossRebornInfo.tagMCBossRebornTaskInfo[] _tasks)
        {
            foreach (var task in _tasks)
            {
                if (bossRebornTasks.ContainsKey(task.TaskID))
                {
                    bossRebornTasks[task.TaskID].UpdateActivityBaseData(task);
                }
                else
                {
                    bossRebornTasks[task.TaskID] = new BossRebornTask(task);
                }
            }
        }

        public List<BossRebornTask> GetTasks()
        {
            return new List<BossRebornTask>(bossRebornTasks.Values);
        }

        public BossRebornTask GetTaskData(int _id)
        {
            if (!bossRebornTasks.ContainsKey(_id))
            {
                bossRebornTasks[_id] = new BossRebornTask(_id);
            }

            return bossRebornTasks[_id];
        }

        public void RequestTaskReward(int _id)
        {
            var sendInfo = new CA504_tagCMPlayerGetReward();
            sendInfo.RewardType = (int)GotServerRewardType.Def_RewardType_BossReborn;
            sendInfo.DataEx = (uint)_id;
            sendInfo.DataExStrLen = 0;
            sendInfo.DataExStr = string.Empty;
            GameNetSystem.Instance.SendInfo(sendInfo);
        }

        public void UpdateTaskData(HAB03_tagMCBossRebornPlayerInfo _serverInfo)
        {
            foreach (var info in _serverInfo.DataList)
            {
                var id = info.ActID;
                var data = GetTaskData(id);
                var oldState = data.GetState();
                data.UpdateActivityData(info.CurTimes, info.GotTimes);
                var newState = data.GetState();

                if (oldState != newState && bossTaskStateChangeEvent != null)
                {
                    bossTaskStateChangeEvent(id);
                }
            }

            UpdateRedpoint();
        }

        private void UpdateRedpoint()
        {
            if (!IsOpen)
            {
                bossRebornPoint.state = RedPointState.None;
            }
            else
            {
                var rewardable = false;
                foreach (var task in bossRebornTasks.Values)
                {
                    if (task.GetState() == BossRebornTask.State.Rewardable)
                    {
                        rewardable = true;
                        break;
                    }
                }

                bossRebornPoint.state = rewardable ? RedPointState.GetReward : RedPointState.None;
            }
        }


    }


}