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

        public bool IsInDungeon { get; private set; }

        public int invincibleBuffId { get; private set; }

        public const int CLIENTDATAMAP = 2000;

        public const int DATAMAP = 22030;
        public const int CROSSSERVERDATAMAP = 32030;

        public event Action onPlayerInfoRefresh;
        public event Action onPlayerCountRefresh;

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

        public override void Init()
        {
            var funcConfig = FuncConfigConfig.Get("HazyDemonKingInvincibleBuff");
            if (funcConfig != null)
            {
                invincibleBuffId = int.Parse(funcConfig.Numerical1);
            }

            StageLoad.Instance.onStageLoadFinish += OnStageLoadFinish;
            GlobalTimeEvent.Instance.secondEvent += PerSecond;
        }

        public void OnBeforePlayerDataInitialize()
        {
            m_PlayerInfos.Clear();
            m_MapPlayerCounts.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;

            GA_Hero.OnStartBeAttacked -= OnStartBeAttacked;
            GA_Hero.OnStopBeAttacked -= OnStopBeAttacked;

            m_AttackHeroPlayers.Clear();

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

                GA_Hero.OnStartBeAttacked += OnStartBeAttacked;
                GA_Hero.OnStopBeAttacked += OnStopBeAttacked;
            }
        }

        private void OnStopBeAttacked(uint sid)
        {
            if (m_AttackHeroPlayers.Contains(sid))
            {
                m_AttackHeroPlayers.Remove(sid);
            }
        }

        private void OnStartBeAttacked(uint sid)
        {
            if (!m_AttackHeroPlayers.Contains(sid))
            {
                m_AttackHeroPlayers.Add(sid);
            }
        }

        private void PerSecond()
        {
            if (!(StageLoad.Instance.currentStage is DungeonStage))
            {
                return;
            }

            if (IsInDungeon)
            {
                var requireRefreshPlayer = false;
                var actors = GAMgr.Instance.GetGroupList(E_ActorGroup.Player);

                var playerCount = 0;
                foreach (var sid in m_PlayerInfos.Keys)
                {
                    if (sid != PlayerDatas.Instance.PlayerId)
                    {
                        playerCount++;
                    }
                }

                if ((actors != null && actors.Count != playerCount)
                    || (actors == null && playerCount != 0))
                {
                    requireRefreshPlayer = true;
                }
                else if (actors != null)
                {
                    foreach (var actor in actors)
                    {
                        if (actor == null)
                        {
                            continue;
                        }
                        var player = actor as GA_Player;
                        if (player == null)
                        {
                            continue;
                        }
                        if (!m_PlayerInfos.ContainsKey(player.ServerInstID))
                        {
                            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)
                {
                    if (actor == null)
                    {
                        continue;
                    }
                    var player = actor as GA_Player;
                    if (player == null)
                    {
                        continue;
                    }
                    if (!m_PlayerInfos.ContainsKey(player.ServerInstID))
                    {
                        m_PlayerInfos.Add(player.ServerInstID, new HazyDemonKingPlayerInfo()
                        {
                            job = player.ActorInfo.Job,
                            face = player.ActorInfo.face,
                            facePic = player.ActorInfo.facePic,
                            hp = player.ActorInfo.RealHp,
                            maxHp = player.ActorInfo.RealMaxHp,
                            playerName = UIHelper.ServerStringTrim(player.ActorInfo.PlayerName),
                        });
                    }
                }
            }

            var playerId = PlayerDatas.Instance.PlayerId;
            if (!m_PlayerInfos.ContainsKey(playerId))
            {
                var hero = PlayerDatas.Instance.hero;
                m_PlayerInfos.Add(playerId, new HazyDemonKingPlayerInfo()
                {
                    job = PlayerDatas.Instance.baseData.Job,
                    face = AvatarHelper.GetMyAvatarID(),
                    facePic = AvatarHelper.GetMyAvatarFrameID(),
                    hp = hero.ActorInfo.RealHp,
                    maxHp = hero.ActorInfo.RealMaxHp,
                    playerName = PlayerDatas.Instance.baseData.PlayerName,
                });
            }

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

        public bool IsInDemonKingDungeon(int mapId)
        {
            if (!(StageLoad.Instance.currentStage is DungeonStage))
            {
                return false;
            }

            if (mapId == CLIENTDATAMAP)
            {
                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 int GetDungeonPlayerCount(int mapId, int lineId)
        {
            if (m_MapPlayerCounts.ContainsKey(mapId))
            {
                return m_MapPlayerCounts[mapId].ContainsKey(lineId) ? m_MapPlayerCounts[mapId][lineId] : 0;
            }
            return 0;
        }

        public void SendSelectAtkTarget(uint serverInstId)
        {
            var actor = GAMgr.Instance.GetBySID(serverInstId);
            if (actor != null)
            {
                var hero = PlayerDatas.Instance.hero;
                if (hero != null)
                {
                    hero.LockTarget = actor;
                    hero.SelectTarget = actor;
                }
            }
        }

        public uint GetPlayerAtkTarget(uint sid)
        {
            if (ClientDungeonStageUtility.clientMapId == CLIENTDATAMAP)
            {
                return ClientHazyDemonKingStage.GetClientBossSid();
            }
            if (sid == PlayerDatas.Instance.PlayerId)
            {
                var hero = PlayerDatas.Instance.hero;
                if (hero != null && hero.SelectTarget != null)
                {
                    return hero.SelectTarget.ServerInstID;
                }
            }
            else
            {
                if (m_AttackHeroPlayers.Contains(sid))
                {
                    return PlayerDatas.Instance.PlayerId;
                }
            }
            return 0;
        }

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

        public void RequestExitDungeon()
        {
            if (PlayerDatas.Instance.baseData.MapID == DATAMAP)
            {
                ModelCenter.Instance.GetModel<DungeonModel>().ExitCurrentDungeon();
            }
            else
            {
                var pak = new CC104_tagCMExitCrossRealm();
                GameNetSystem.Instance.SendToCrossServer(pak);
            }
        }

        public void ReceivePackage(HA007_tagGCFBLinePlayerCnt package)
        {
            var mapId = (int)package.MapID;
            if (IsInDemonKingDungeon(mapId))
            {
                Dictionary<int, int> dict = null;
                if (!m_MapPlayerCounts.TryGetValue(mapId, out dict))
                {
                    dict = new Dictionary<int, int>();
                    m_MapPlayerCounts.Add(mapId, dict);
                }
                for (int i = 0; i < package.Count; i++)
                {
                    var data = package.FBLineInfoList[i];
                    dict[data.FBLineID] = data.PlayerCnt;
                }

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

        public void RequestEnterClientDungeon()
        {
            var config = HazyRegionConfig.Get(hazyRegionModel.processingIncidentId);
            ClientDungeonStageUtility.GotoNormalClientDungeon(CLIENTDATAMAP, config.dungeonId, config.lineId);
        }
    }

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