using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace Snxxz.UI
{
    public class HazyDemonKingModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
    {
        Dictionary<uint, HazyDemonKingPlayerInfo> m_PlayerInfos = new Dictionary<uint, HazyDemonKingPlayerInfo>();

        public bool IsInDungeon { get; private set; }

        public int invincibleBuffId { get; private set; }

        public const int Client_MapID = 2000;

        public const int DEMONKINGMAPID1 = 22030;
        public const int DEMONKINGMAPID2 = 32030;

        public event Action onPlayerInfoRefresh;

        HazyRegionModel hazyRegionModel { get { return ModelCenter.Instance.GetModel<HazyRegionModel>(); } }

        public override void Init()
        {
            StageLoad.Instance.onStageLoadFinish += OnStageLoadFinish;
            GlobalTimeEvent.Instance.secondEvent += PerSecond;
        }

        public void OnBeforePlayerDataInitialize()
        {
            m_PlayerInfos.Clear();
        }

        public void OnPlayerLoginOk()
        {

        }

        public override void UnInit()
        {
            StageLoad.Instance.onStageLoadFinish -= OnStageLoadFinish;
            GlobalTimeEvent.Instance.secondEvent -= PerSecond;
        }

        private void OnStageLoadFinish()
        {
            var mapId = PlayerDatas.Instance.baseData.MapID;

            IsInDungeon = false;
            if (IsInDemonKingDungeon(mapId))
            {
                IsInDungeon = true;
                RefreshAroundPlayer();
            }
        }

        private void PerSecond()
        {
            if (IsInDungeon)
            {
                var requireRefreshPlayer = false;
                var actors = GAMgr.Instance.GetGroupList(E_ActorGroup.Player);
                if ((actors != null && actors.Count != m_PlayerInfos.Count)
                    || (actors == null && m_PlayerInfos.Count != 0))
                {
                    requireRefreshPlayer = true;
                }
                else if (actors != null)
                {
                    foreach (var actor in actors)
                    {
                        var player = actor as GA_Player;
                        if (!m_PlayerInfos.ContainsKey(player.ServerInstID))
                        {
                            requireRefreshPlayer = true;
                        }
                    }
                }

                var playerId = PlayerDatas.Instance.PlayerId;
                if (IsExistBelongTo(playerId))
                {
                    if (!m_PlayerInfos.ContainsKey(playerId))
                    {
                        requireRefreshPlayer = true;
                    }
                }
                else
                {
                    if (m_PlayerInfos.ContainsKey(playerId))
                    {
                        requireRefreshPlayer = true;
                    }
                }

                if (requireRefreshPlayer)
                {
                    RefreshAroundPlayer();
                }
            }
        }

        public void RefreshAroundPlayer()
        {
            m_PlayerInfos.Clear();
            var actors = GAMgr.Instance.GetGroupList(E_ActorGroup.Player);
            if (actors != null)
            {
                foreach (var actor in actors)
                {
                    var player = actor as GA_Player;
                    if (!m_PlayerInfos.ContainsKey(player.ServerInstID))
                    {
                        m_PlayerInfos.Add(player.ServerInstID, new HazyDemonKingPlayerInfo()
                        {
                            job = player.ActorInfo.Job,
                            hp = player.ActorInfo.RealHp,
                            maxHp = player.ActorInfo.RealMaxHp,
                            playerName = UIHelper.ServerStringTrim(player.ActorInfo.PlayerName),
                        });
                    }
                }
            }

            var playerId = PlayerDatas.Instance.PlayerId;
            if (IsExistBelongTo(playerId))
            {
                if (!m_PlayerInfos.ContainsKey(playerId))
                {
                    var hero = PlayerDatas.Instance.hero;
                    m_PlayerInfos.Add(playerId, new HazyDemonKingPlayerInfo()
                    {
                        job = PlayerDatas.Instance.baseData.Job,
                        hp = hero.ActorInfo.RealHp,
                        maxHp = hero.ActorInfo.RealMaxHp,
                        playerName = PlayerDatas.Instance.baseData.PlayerName,
                    });
                }
            }
            else
            {
                if (m_PlayerInfos.ContainsKey(playerId))
                {
                    m_PlayerInfos.Remove(playerId);
                }
            }

            if (onPlayerInfoRefresh != null)
            {
                onPlayerInfoRefresh();
            }
        }

        public bool IsInDemonKingDungeon(int mapId)
        {
            if (mapId == Client_MapID)
            {
                return true;
            }

            var configs = HazyRegionConfig.GetValues();
            foreach (var config in configs)
            {
                if (config.incidentType == (int)HazyRegionIncidentType.DemonKing
                    && config.dungeonId == mapId)
                {
                    return true;
                }
            }
            return false;
        }

        public bool TryGetPlayerInfo(uint playerId, out HazyDemonKingPlayerInfo playerInfo)
        {
            return m_PlayerInfos.TryGetValue(playerId, out playerInfo);
        }

        public ICollection<uint> GetPlayerIds()
        {
            return m_PlayerInfos.Keys;
        }

        public void SendSelectAtkTarget(uint serverInstId)
        {

        }

        public uint GetPlayerAtkTarget(uint serverInstId)
        {
            if (ClientDungeonStageUtility.clientMapId == Client_MapID)
            {
                return ClientHazyDemonKingStage.GetClientBossSid();
            }
            return 0;
        }

        public bool IsExistBelongTo(uint playerId)
        {
            if (playerId == PlayerDatas.Instance.PlayerId
                && ClientDungeonStageUtility.clientMapId == Client_MapID)
            {
                return true;
            }
            return StatusMgr.Instance.IsExistBossBelong(playerId);
        }

        public void RequestEnterClientDungeon()
        {
            var config = HazyRegionConfig.Get(hazyRegionModel.processingIncidentId);

            MapTransferUtility.Instance.Clear();
            ClientDungeonStageUtility.SetClientDungeon(true, Client_MapID);
            ClientDungeonStageUtility.RequestStartClientDungeon(config.dungeonId, config.lineId);
            CrossServerLogin.Instance.SetWaitForLoginCrossServerState(false);
            StageLoad.Instance.PushSceneLoadCommand(new StageLoad.StageLoadCommand()
            {
                toMapId = Client_MapID,
                toLineId = 0,
                needEmpty = true,
                needLoadResource = true,
                serverType = ServerType.Main,
                isClientLoadMap = true
            });

            PlayerDatas.Instance.baseData.mainServerMapIdRecord = PlayerDatas.Instance.baseData.MapID;
            PlayerDatas.Instance.baseData.MapID = Client_MapID;
            var attackMode = new C030A_tagCChangeAttackMode();
            attackMode.Mode = (byte)E_AttackMode.Peace;
            GameNetSystem.Instance.PushPackage(attackMode, ServerType.Main);
        }

        public void RequestExitClientDungeon()
        {
            ClientDungeonStageUtility.SetClientDungeon(false, 0);
            ClientDungeonStageUtility.RequestExitClientDungeon();
            PlayerDatas.Instance.extersion.pkState = 0;
            ModelCenter.Instance.GetModel<DungeonModel>().ResetBufData();

            PlayerDatas.Instance.baseData.MapID = PlayerDatas.Instance.baseData.mainServerMapIdRecord;
            StageLoad.Instance.PushSceneLoadCommand(new StageLoad.StageLoadCommand()
            {
                toMapId = PlayerDatas.Instance.baseData.MapID,
                toLineId = 0,
                needEmpty = true,
                needLoadResource = true,
                serverType = ServerType.Main,
                isClientLoadMap = true
            });
        }
    }

    public struct HazyDemonKingPlayerInfo
    {
        public string playerName;
        public int job;
        public ulong hp;
        public ulong maxHp;
    }
}