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

namespace vnxbqy.UI
{
    public class HazyRegionIncidentBehaviour : ScrollItem
    {
        [SerializeField] SmoothMask m_SmoothMask;
        [SerializeField] UIAlphaTween m_AlphaTween;
        [SerializeField] UILinerMove m_LinerMove;
        [SerializeField] Text m_IncidentTitle;
        [SerializeField] Text m_DepletionPoint;
        [SerializeField] ImageEx m_Icon;

        [SerializeField] Transform m_ContainerCrossServer;
        [SerializeField] Transform m_ContainerMustSign;

        [SerializeField] Transform m_ContainerItem;
        [SerializeField] ItemBehaviour[] m_Items;
        [SerializeField] Text[] m_ItemDescriptions;

        [SerializeField] Transform m_ContainerProcessing;
        [SerializeField] Transform m_ContainerCompleted;

        [SerializeField] Transform m_ContainerSelect;
        [SerializeField] Button m_Select;

        [SerializeField] Transform m_RedpointSign;

        [SerializeField] Transform m_ContainerStar;
        [SerializeField] Transform[] m_Stars;

        [SerializeField] Transform m_ContainerName;
        [SerializeField] Text m_NpcName;

        [Header("Boss")]
        [SerializeField] Transform m_ContainerBoss;
        [SerializeField] Transform m_BossAliveInfo;
        [SerializeField] Text m_PlayerCount;
        [SerializeField] Text m_RebornTime;

        [Header("宝藏")]
        [SerializeField] UIEffect m_TitleEffect;

        public UIAlphaTween alphaTween { get { return m_AlphaTween; } }
        public UILinerMove linerMove { get { return m_LinerMove; } }

        HazyRegionModel model { get { return ModelCenter.Instance.GetModel<HazyRegionModel>(); } }
        FindPreciousModel findPreciousModel { get { return ModelCenter.Instance.GetModel<FindPreciousModel>(); } }
        HazyDemonKingModel hazyDemonKingModel { get { return ModelCenter.Instance.GetModel<HazyDemonKingModel>(); } }

        int incidentId = 0;

        bool m_BossAlive = false;
        bool bossAlive
        {
            get { return m_BossAlive; }
            set
            {
                if (m_BossAlive != value)
                {
                    m_BossAlive = value;
                    DisplayBossState();

                    if (m_BossAlive)
                    {
                        model.incidentDirty = true;
                    }
                }
            }
        }

        bool m_RedpointAble = false;
        bool redpointAble
        {
            get { return m_RedpointAble; }
            set
            {
                if (m_RedpointAble != value)
                {
                    m_RedpointAble = value;
                    DisplayRedpointSign();
                }
            }
        }

        float timer = 0f;

        HazyRegionIncidentType incidentType = HazyRegionIncidentType.Adventure;

        private void Awake()
        {
            m_Select.SetListener(OnSelect);
        }

        public override void Display(object _data)
        {
            base.Display(_data);

            incidentId = (int)_data;
            var config = HazyRegionConfig.Get(incidentId);
            incidentType = (HazyRegionIncidentType)config.incidentType;

            m_BossAlive = false;
            if (incidentType == HazyRegionIncidentType.DemonKing)
            {
                m_BossAlive = findPreciousModel.IsBossAlive(config.npcId);
            }

            HazyRegionModel.Incident incident;
            model.TryGetIncident(incidentId, out incident);
            var error = 0;
            redpointAble = model.TryGotoIncident(incidentId, false, out error)
                && incident.state == HazyRegionModel.IncidentState.Processing;


            DisplayBase();
            DisplayItems();
            DisplayStars();
            DisplayState();
            DisplaySelect();
            DisplayBoss();
            DisplayNpcName();
            DisplayRedpointSign();

            model.selectIncidentRefresh -= SelectIncidentRefresh;
            model.selectIncidentRefresh += SelectIncidentRefresh;
            model.onHazyRegionIncidentRefresh -= OnHazyRegionIncidentRefresh;
            model.onHazyRegionIncidentRefresh += OnHazyRegionIncidentRefresh;
            findPreciousModel.bossInfoUpdateEvent -= BossInfoUpdateEvent;
            findPreciousModel.bossInfoUpdateEvent += BossInfoUpdateEvent;
            hazyDemonKingModel.onPlayerCountRefresh -= OnPlayerCountRefresh;
            hazyDemonKingModel.onPlayerCountRefresh += OnPlayerCountRefresh;

            m_TitleEffect.SetActive(false);
            //switch (incidentType)
            //{
            //    case HazyRegionIncidentType.Precious:
            //        m_TitleEffect.SetActive(true);
            //        break;
            //}
        }

        void DisplayBase()
        {
            var config = HazyRegionConfig.Get(incidentId);
            m_DepletionPoint.SetActive(false);
            m_DepletionPoint.text = Language.Get("HazyRegionPoint", config.point);
            m_IncidentTitle.text = config.name;
            m_Icon.SetSprite(config.PortraitID);
            m_Icon.SetNativeSize();
            m_Icon.material = m_SmoothMask.imageMaterials[0];
            m_ContainerCrossServer.SetActive(config.dungeonType == 2);
            m_ContainerMustSign.SetActive(false);
        }

        void DisplayItems()
        {
            var config = HazyRegionConfig.Get(incidentId);
            for (int i = 0; i < m_Items.Length; i++)
            {
                if (config.reward != null && i < config.reward.Length)
                {
                    m_Items[i].SetActive(true);
                    m_Items[i].SetItem(config.reward[i], 1);
                    m_ItemDescriptions[i].SetActive(true);
                    m_ItemDescriptions[i].text = config.rewardState[i] == 0 ? string.Empty :
                        Language.Get(StringUtility.Contact("HazyRegionItemState_", config.rewardState[i]));
                }
                else
                {
                    m_Items[i].SetActive(false);
                    m_ItemDescriptions[i].SetActive(false);
                }
            }
        }

        void DisplayStars()
        {
            var config = HazyRegionConfig.Get(incidentId);
            m_ContainerStar.SetActive(config.star > 0);
            if (config.star > 0)
            {
                for (int i = 0; i < m_Stars.Length; i++)
                {
                    m_Stars[i].SetActive(i < config.star);
                }
            }
        }

        void DisplayNpcName()
        {
            m_ContainerName.SetActive(incidentType == HazyRegionIncidentType.DemonKing
                || incidentType == HazyRegionIncidentType.Adventure);
            if (incidentType == HazyRegionIncidentType.DemonKing
                || incidentType == HazyRegionIncidentType.Adventure)
            {
                var config = HazyRegionConfig.Get(incidentId);
                var npcConfig = NPCConfig.Get(config.npcId);
                m_NpcName.text = npcConfig.charName;
            }
        }

        void DisplayBoss()
        {
            m_ContainerBoss.SetActive(incidentType == HazyRegionIncidentType.DemonKing);

            DisplayBossState();
        }

        void DisplayBossState()
        {
            if (incidentType == HazyRegionIncidentType.DemonKing)
            {
                var config = HazyRegionConfig.Get(incidentId);
                if (config.dungeonType == 0)
                {
                    m_BossAliveInfo.SetActive(false);
                    //var fighting = ClientDungeonStageUtility.isClientDungeon &&
                    //    ClientDungeonStageUtility.clientMapId == HazyDemonKingModel.CLIENTDATAMAP;
                    //m_PlayerCount.SetActive(true);
                    //m_RebornTime.SetActive(false);
                    //m_PlayerCount.text = Language.Get("HazyDemonKingPlayerCount", fighting ? 1 : 0);
                }
                else
                {
                    m_BossAliveInfo.SetActive(true);
                    m_PlayerCount.SetActive(bossAlive);
                    m_RebornTime.SetActive(!bossAlive);
                    m_Icon.material = bossAlive ? m_SmoothMask.imageMaterials[0] : m_SmoothMask.imageMaterials[1];
                    if (!bossAlive)
                    {
                        DisplayBossRebornTime();
                    }
                    else
                    {
                        DisplayPlayerCount();
                    }
                }
            }
        }

        void DisplayBossRebornTime()
        {
            var config = HazyRegionConfig.Get(incidentId);
            if (config != null)
            {
                FindPreciousModel.BossInfo bossInfo;
                if (findPreciousModel.TryGetBossInfo(config.npcId, out bossInfo))
                {
                    var seconds = Mathf.Max(0, Mathf.CeilToInt((float)(bossInfo.refreshTime - TimeUtility.ServerNow).TotalSeconds));
                    m_RebornTime.text = Language.Get("HazyDemonKingRefresh", TimeUtility.SecondsToHMS(seconds));
                }
                else
                {
                    m_RebornTime.text = Language.Get("BossReborn_RefreshTime1");
                }
            }
        }

        void DisplayPlayerCount()
        {
            var config = HazyRegionConfig.Get(incidentId);
            if (config != null)
            {
                m_PlayerCount.text = Language.Get("HazyDemonKingPlayerCount",
                    hazyDemonKingModel.GetDungeonPlayerCount(config.dungeonId, config.lineId));
            }
        }

        void DisplayRedpointSign()
        {
            m_RedpointSign.SetActive(redpointAble);
        }

        private void LateUpdate()
        {
            timer += Time.deltaTime;
            if (timer >= 0.5f)
            {
                timer = 0f;
                if (incidentType == HazyRegionIncidentType.DemonKing)
                {
                    if (!bossAlive)
                    {
                        DisplayBossRebornTime();
                    }

                    var config = HazyRegionConfig.Get(incidentId);
                    bossAlive = findPreciousModel.IsBossAlive(config.npcId);
                }

                HazyRegionModel.Incident incident;
                if (model.TryGetIncident(incidentId, out incident))
                {
                    var error = 0;
                    redpointAble = model.TryGotoIncident(incidentId, false, out error)
                        && incident.state == HazyRegionModel.IncidentState.Processing;
                }
            }
        }

        void DisplayState()
        {
            HazyRegionModel.Incident incident;
            if (model.TryGetIncident(incidentId, out incident))
            {
                m_ContainerCompleted.SetActive(incident.state == HazyRegionModel.IncidentState.Complete);
                m_ContainerProcessing.SetActive(incident.state == HazyRegionModel.IncidentState.Processing);
            }
        }

        void DisplaySelect()
        {
            m_ContainerSelect.SetActive(incidentId == model.selectIncident);
        }

        private void SelectIncidentRefresh()
        {
            DisplaySelect();
        }

        private void OnHazyRegionIncidentRefresh()
        {
            DisplayState();
        }

        private void OnSelect()
        {
            model.selectIncident = incidentId;
        }

        private void BossInfoUpdateEvent(int npcId)
        {
            if (incidentType == HazyRegionIncidentType.DemonKing)
            {
                var config = HazyRegionConfig.Get(incidentId);
                if (config.npcId == npcId)
                {
                    DisplayBossState();
                }
            }
        }

        private void OnPlayerCountRefresh()
        {
            var config = HazyRegionConfig.Get(incidentId);
            if (incidentType == HazyRegionIncidentType.DemonKing
                && config.dungeonType != 0 && bossAlive)
            {
                DisplayPlayerCount();
            }
        }

        public override void Dispose()
        {
            base.Dispose();
            hazyDemonKingModel.onPlayerCountRefresh -= OnPlayerCountRefresh;
            findPreciousModel.bossInfoUpdateEvent -= BossInfoUpdateEvent;
            model.selectIncidentRefresh -= SelectIncidentRefresh;
            model.onHazyRegionIncidentRefresh -= OnHazyRegionIncidentRefresh;

            alphaTween.SetEndState();
        }
    }
}