using Assets.MyGame.Scripts.Net.WebResponses;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.SceneManagement;

namespace Assets.MyGame.Scripts.Net
{
    public class WebSocketReponseList
    {
        /// <summary>正在加载中的游戏场景 UIPanel 集合，防止房主收到多条 RoomJoinNotice（含人机）时重复创建场景</summary>
        private static readonly HashSet<UIPanel> _loadingGamePanels = new HashSet<UIPanel>();
        /// <summary>
        /// 获取房间列表 room
        /// </summary>
        /// <param name="msg"></param>
        public static void GetRoomListChineseChessResult(string msg)
        {
            var var1 = UIManager.Instance.Show<UIChineseChessDistrict>(UIPanel.MainGamePanelZGXQ, msg);
        }
        public static void GetGoldConfigSuccessChineseChessResult(string msg)
        {
            UIManager.Instance.Get<ChineseChessMainPanel>(UIPanel.MainGamePanelZGXQ).subUIManager.ShowAsync(UIPanel.ZGXQGameExplain);
        }

        /// <summary>
        /// 获取房间列表 room
        /// </summary>
        /// <param name="msg"></param>
        public static void GetRoomListResult(string msg)
        {
            var var1 = UIManager.Instance.Get<UIHomeMain>(UIPanel.HomeMainPanel);

            var selectRoomPanel = var1.subUIManager.Get<UIHome_BY_SelectRoomLevelPanel>(UIPanel.SelectRoomLeavePenel);
            if (selectRoomPanel != null && selectRoomPanel.isMySelectRoom)
                selectRoomPanel.panel_UIHome_BY_MySelectRoomPenel.Show(msg);

            else
            {
                var v = JsonConvert.DeserializeObject<WebSocketResponseBase<List<GetRoomList>>>(msg).arguments[0];


                foreach (var item in v)
                {
                    if (item.currentOnlinePlayerCount < item.maxPlayerCount)
                    {
                        WebSocketSendList.GetRoomInfo(item.roomId);
                        break;
                        //if (item)
                        //{
                        //UIHome_BY_SelectRoomLevelPanel.StartGame(item);
                        //}

                    }
                }
            }
        }
        /// <summary>
        /// 加入房间 room
        /// </summary>
        /// <param name="msg"></param>
        public static void RoomJoinNotice(string msg)
        {
            string sceneName = "";
            UIPanel uIPanel = UIPanel.None;
            switch (GameManager.Instance.gameData.currGameType)
            {
                case GameType.JQQD:
                    break;
                case GameType.defaultPanel:
                    break;
                case GameType.FLZY:
                    sceneName = "FLZY";
                    uIPanel = UIPanel.MainGamePanelFLZY;
                    break;
                case GameType.YYSC:
                    sceneName = "YYSC";

                    uIPanel = UIPanel.MainGamePanelYYSC;

                    break;
                case GameType.ZGXQ:
                    break;
                case GameType.XJMH:
                    sceneName = "XJMH";
                    uIPanel = UIPanel.MainGamePanelXJMH;
                    break;
                case GameType.HHWK:
                    sceneName = "HHWK";
                    uIPanel = UIPanel.MainGamePanelHHWK;
                    break;
                default:
                    break;
            }
            if (UIManager.Instance.Get<GameMainPanel_Base>(uIPanel)==null && !_loadingGamePanels.Contains(uIPanel))
            {
                // 标记正在加载，防止房主收到多条 RoomJoinNotice（含人机玩家）时重复创建场景
                _loadingGamePanels.Add(uIPanel);
                UIManager.Instance.ShowAsync(uIPanel, UIPanel.HomeMainPanel, msg, (panel) =>
                {
                    // 面板创建完成，移除加载标记
                    _loadingGamePanels.Remove(uIPanel);
                });
                // 卸载所有已加载的游戏地图场景（保证场景唯一性）
                string[] gameScenes = { "FLZY", "YYSC", "XJMH", "HHWK" };
                foreach (var sn in gameScenes)
                {
                    // 不卸载即将加载的目标场景
                    if (sn == sceneName) continue;
                    var s = SceneManager.GetSceneByName(sn);
                    if (s.IsValid() && s.isLoaded)
                        SceneManager.UnloadSceneAsync(sn);
                }
                // 目标场景已加载则不重复加载
                var targetScene = SceneManager.GetSceneByName(sceneName);
                if (!targetScene.IsValid() || !targetScene.isLoaded)
                    SceneManager.LoadSceneAsync(sceneName, LoadSceneMode.Additive);

                UIManager.Instance.Close(UIPanel.HomeMainPanel);
                WebSocketManager.Instance.isGame = true;
            }
            else if (UIManager.Instance.Get<GameMainPanel_Base>(uIPanel) != null)
            {
                // 面板已存在 → 新玩家加入，转发给现有面板激活座位
                var panel = UIManager.Instance.Get<GameMainPanel_Base>(uIPanel);
                if (panel is GameMainPanel_FishBase fishPanel)
                {
                    var v = JsonConvert.DeserializeObject<WebSocketResponseBase<RoomJoinNotice>>(msg);
                    if (v.arguments.Count > 0)
                    {
                        var notice = v.arguments[0];
                        // 如果座位被bot占用则替换
                        var targetSit = fishPanel.list_Sits.Find(s => s.posID == notice.position);
                        if (targetSit != null && targetSit.isBot)
                        {
                            targetSit.isBot = false;
                            targetSit.ShowWaiting();
                        }
                        fishPanel.JoinGame(notice.position, notice.gold, notice.diamond, notice.cannonMultiple, 0, notice.userId, notice.cannonId, notice.wingsId);
                        // 后端动态加入的机器人也要标记
                        if (targetSit != null && !string.IsNullOrEmpty(notice.userId) && notice.userId.StartsWith("bot_"))
                            targetSit.isBot = true;
                    }
                }
            }
            // else: 场景正在加载中（_loadingGamePanels 含此 uIPanel），忽略本次重复通知
           

        }
        /// <summary>
        /// 房间列表 room
        /// </summary>
        /// <param name="msg"></param>
        public static void RoomInfo(string msg)
        {
            WebSocketManager.Instance.isGame = false;
            var roomData = JsonConvert.DeserializeObject<WebSocketResponseBase<RoomChangeResponse>>(msg).arguments[0];
            if (roomData != null)
            {
                GameManager.Instance.gameData.currRoomData = roomData;
            }
            else
            {
                Debug.LogError("roomdata是空:" + msg);
            }
        }
        public static void RoomKillNotice(string msg)
        {
            // 离开倒计时期间不触发击杀/爆奖特效
            var panel = UIManager.Instance.Get<GameMainPanel_FishBase>(UIPanel.MainGamePanelDefault)
                ?? UIManager.Instance.Get<GameMainPanel_FishBase>(UIPanel.MainGamePanelFLZY)
                ?? UIManager.Instance.Get<GameMainPanel_FishBase>(UIPanel.MainGamePanelYYSC)
                ?? UIManager.Instance.Get<GameMainPanel_FishBase>(UIPanel.MainGamePanelXJMH)
                ?? UIManager.Instance.Get<GameMainPanel_FishBase>(UIPanel.MainGamePanelHHWK);
            if (panel != null && panel.IsLeavingCountdown()) return;
            CreateFishManager.Instance.Ws_DieFish(msg);
        }
        public static void RoomFireNotice(string msg)
        {
            FireCannonSendData fireCannonSendData = JsonConvert.DeserializeObject<WebSocketResponseBase<FireCannonSendData>>(msg).arguments[0];
            var syncGameData = fireCannonSendData.extra;

            EventCenter.Instance.EventTrigger<FireCannonSendData>(ConstEventString.SyncGameData_FireBullet, fireCannonSendData);
        }

        public static void SyncPlayerGold(string msg)
        {
            var gold = JsonConvert.DeserializeObject<WebSocketResponseBase<long>>(msg).arguments[0];
            switch (GameManager.Instance.gameData.currGameType)
            {
                case GameType.JQQD:
                    break;
                case GameType.defaultPanel:
                    UIManager.Instance.Get<GameMainPanel_FishBase>(UIPanel.MainGamePanelDefault).currSitData.goldNum = gold;

                    break;
                case GameType.FLZY:
                    UIManager.Instance.Get<GameMainPanel_FishBase>(UIPanel.MainGamePanelFLZY).currSitData.goldNum = gold;

                    break;
                case GameType.YYSC:
                    UIManager.Instance.Get<GameMainPanel_FishBase>(UIPanel.MainGamePanelYYSC).currSitData.goldNum = gold;

                    break;
                case GameType.ZGXQ:

                    break;
                case GameType.XJMH:
                    UIManager.Instance.Get<GameMainPanel_FishBase>(UIPanel.MainGamePanelXJMH).currSitData.goldNum = gold;

                    break;
                case GameType.HHWK:
                    UIManager.Instance.Get<GameMainPanel_FishBase>(UIPanel.MainGamePanelHHWK).currSitData.goldNum = gold;

                    break;
                default:
                    break;
            }
        }
        public static void GetRoomInfoResult(string msg)
        {
            //GameManager.Instance.StartGame();RoomChangeResponse
            var roomData = JsonConvert.DeserializeObject<WebSocketResponseBase<RoomChangeResponse>>(msg).arguments[0];
            UIHome_BY_SelectRoomLevelPanel.StartGame(roomData);
        }
        public static void SyncGameDataResult(string msg)
        {
            var syncGameData = JsonConvert.DeserializeObject<WebSocketResponseBase<SyncGameData>>(msg).arguments[0];
            switch (syncGameData.frameType)
            {
                case FrameDataType.none:
                    break;
                case FrameDataType.rotateTurrect:
                    EventCenter.Instance.EventTrigger<SyncGameData>(ConstEventString.SyncGameData_Rotate, syncGameData);
                    break;
                case FrameDataType.fireBullet:
                    // 机器人角度同步：SyncFire_ForBot 发出的 SyncGameData(fireBullet)
                    // 与 RoomFireNotice(FireCannonSendData) 分开处理，仅用于存储角度到 botLastAngle
                    EventCenter.Instance.EventTrigger<SyncGameData>(ConstEventString.SyncGameData_BotFireAngle, syncGameData);
                    break;
                case FrameDataType.createFish:
                    EventCenter.Instance.EventTrigger<SyncGameData>(ConstEventString.SyncGameData_CreateFish, syncGameData);
                    break;
                case FrameDataType.changeAutoTarget:
                    EventCenter.Instance.EventTrigger<SyncGameData>(ConstEventString.SyncGameData_ChangeTargetMonster, syncGameData);
                    break;
                case FrameDataType.randomDieFish:
                    EventCenter.Instance.EventTrigger<SyncGameData>(ConstEventString.SyncGameData_RendromDieFish, syncGameData);
                    break;
                case FrameDataType.freezeFish:
                    EventCenter.Instance.EventTrigger<SyncGameData>(ConstEventString.SyncGameData_FreezeFish, syncGameData);
                    break;
                case FrameDataType.changeTurretState:
                    EventCenter.Instance.EventTrigger<SyncGameData>(ConstEventString.SyncGameData_TurretState, syncGameData);

                    break;
                case FrameDataType.changeTurret:
                    EventCenter.Instance.EventTrigger<SyncGameData>(ConstEventString.SyncGameData_ChangeTurret, syncGameData);
                    break;
                case FrameDataType.changeCannonMultiple:
                    EventCenter.Instance.EventTrigger<SyncGameData>(ConstEventString.SyncGameData_ChangeCannonMultiple, syncGameData);
                    break;
                case FrameDataType.changeWing:
                    EventCenter.Instance.EventTrigger<SyncGameData>(ConstEventString.SyncGameData_ChangeWing, syncGameData);
                    break;
                default:
                    break;
            }


        }
        public static void LeaveRoomResult(string msg)
        {
            //WebSocketManager.Instance.isGame = false;

            //GameManager.Instance.StartGame();RoomChangeResponse
            var userid = JsonConvert.DeserializeObject<WebSocketResponseBase<string>>(msg).arguments[0];
            switch (GameManager.Instance.gameData.currGameType)
            {
                case GameType.JQQD:
                    break;
                case GameType.defaultPanel:
                    break;
                case GameType.FLZY:
                    {
                        var panel = UIManager.Instance.Get<GameMainPanel_FLZY>(UIPanel.MainGamePanelFLZY);
                        if (panel.currSitData.user == userid)
                        {
                            UIManager.Instance.ShowAsync(UIPanel.HomeMainPanel, UIPanel.MainGamePanelFLZY);
                            break;
                        }
                        foreach (var item in panel.list_Sits)
                        {
                            if (item.user == userid)
                            {
                                item.ShowWaiting();
                            }
                        }
                    }

                    break;
                case GameType.YYSC:
                    {
                        var panel = UIManager.Instance.Get<GameMainPanel_YYSC>(UIPanel.MainGamePanelYYSC);
                        if (panel.currSitData.user == userid)
                        {
                            UIManager.Instance.ShowAsync(UIPanel.HomeMainPanel, UIPanel.MainGamePanelYYSC);
                            break;
                        }
                        foreach (var item in panel.list_Sits)
                        {
                            if (item.user == userid)
                            {
                                item.ShowWaiting();
                            }
                        }
                    }
                    break;
                case GameType.ZGXQ:

                    break;
                case GameType.XJMH:
                    {
                        var panel = UIManager.Instance.Get<GameMainPanel_XJMH>(UIPanel.MainGamePanelXJMH);
                        if (panel.currSitData.user == userid)
                        {
                            UIManager.Instance.ShowAsync(UIPanel.HomeMainPanel, UIPanel.MainGamePanelXJMH);
                            break;
                        }
                        foreach (var item in panel.list_Sits)
                        {
                            Debug.Log(item.user + "---" + userid);
                            if (item.user == userid)
                            {
                                Debug.Log("推出星际迷航");
                                item.ShowWaiting();
                            }
                        }
                    }
                    break;
                case GameType.HHWK:
                    {
                        var panel = UIManager.Instance.Get<GameMainPanel_HHWK>(UIPanel.MainGamePanelHHWK);
                        if (panel.currSitData.user == userid)
                        {
                            UIManager.Instance.ShowAsync(UIPanel.HomeMainPanel, UIPanel.MainGamePanelHHWK);
                            break;
                        }
                        foreach (var item in panel.list_Sits)
                        {
                            if (item.user == userid)
                            {
                                item.ShowWaiting();
                            }
                        }
                    }
                    break;
                default:
                    break;
            }


        }

        // ---------------- LoginHub ----------------

        /// <summary>
        /// LoginHub Broadcast — 大厅公告广播
        /// </summary>
        public static void LoginBroadcast(string msg)
        {
            var data = JsonConvert.DeserializeObject<WebSocketResponseBase<LoginBroadcastData>>(msg).arguments[0];
            UIManager.Instance.ShowBoardGongGao(data.message);
        }

        /// <summary>
        /// LoginHub AssetUpdated — 资产变动通知
        /// </summary>
        public static void AssetUpdated(string msg)
        {
            var data = JsonConvert.DeserializeObject<WebSocketResponseBase<LoginAssetData>>(msg).arguments[0];
            // 触发用户数据刷新
            var userId = GameManager.Instance?.user?.id;
            if (!string.IsNullOrEmpty(userId))
                APIRequestList.GetUser(userId, a => GameManager.Instance.UpdataUserData(a));
        }

        /// <summary>
        /// LoginHub BackpackUpdated — 背包变动通知
        /// </summary>
        public static void BackpackUpdated(string msg)
        {
            var data = JsonConvert.DeserializeObject<WebSocketResponseBase<LoginBackpackData>>(msg).arguments[0];
            // 刷新用户数据（道具列表在 GetUser 返回中）
            var userId = GameManager.Instance?.user?.id;
            if (!string.IsNullOrEmpty(userId))
                APIRequestList.GetUser(userId, a => GameManager.Instance.UpdataUserData(a));
        }

        /// <summary>
        /// LoginHub NewEmail — 新邮件通知
        /// </summary>
        public static void NewEmail(string msg)
        {
            var data = JsonConvert.DeserializeObject<WebSocketResponseBase<LoginNewEmailData>>(msg).arguments[0];
            UIManager.Instance.ShowBoardError($"收到新邮件：{data.title}");
        }

        /// <summary>
        /// LoginHub KillAnnouncement — 全局击杀公告（特殊 Boss 击杀全服推送）
        /// </summary>
        public static void KillAnnouncement(string msg)
        {
            var data = JsonConvert.DeserializeObject<WebSocketResponseBase<KillAnnouncementData>>(msg).arguments[0];
            // 服务端已拼好 text（格式：恭喜玩家*****在风雷之渊 高级场捕获 人鱼公主*2000倍 150000000大奖）
            if (data != null && !string.IsNullOrEmpty(data.text))
                UIManager.Instance.ShowBoardGongGao(data.text);
        }

        // ---------------- Customer ----------------

        /// <summary>
        /// 发起会话回调（用户端）
        /// isOk=false 时弹错误提示；isOk=true 时自动加入会话房间
        /// </summary>
        public static void Customer_OnConversationStarted(CustomerConversationStartedResult result)
        {
            if (!result.isOk)
            {
                UIManager.Instance.ShowBoardError(result.msg);
                return;
            }
            // 加入会话房间，之后才能收发消息
            //WebSocketSendList.Customer_JoinConversation(result.conversation.id);
            // TODO: 通知客服 UI 显示会话（替换为你的实际 Panel 调用）
            UIManager.Instance.Get<UIHomeMain>(UIPanel.HomeMainPanel).subUIManager.Get<UIHome_BY_ServicePanel>(UIPanel.ServicePanel)?.OnConversationStarted(result);

        }

        /// <summary>
        /// 消息接收回调（用户端 & 客服端）
        /// </summary>
        public static void Customer_OnMessageReceived(CustomerMessageReceived msg)
        {

            // TODO: 通知客服 UI 追加消息（替换为你的实际 Panel 调用）
            UIManager.Instance.Get<UIHomeMain>(UIPanel.HomeMainPanel).subUIManager.Get<UIHome_BY_ServicePanel>(UIPanel.ServicePanel)?.OnMessageReceived(msg);
            Debug.Log($"[Customer] 收到消息 from {msg.senderName}({msg.senderType}): {msg.content}");
        }

        /// <summary>
        /// 新会话通知（客服端）
        /// </summary>
        public static void Customer_OnNewConversation(CustomerNewConversationNotice notice)
        {
            // 客服端自动加入会话房间
            WebSocketSendList.Customer_JoinConversation(notice.conversationId);
            // TODO: 通知客服端 UI 显示新会话（替换为你的实际 Panel 调用）
            // UIManager.Instance.Get<UICustomerServicePanel>(UIPanel.CustomerServicePanel)?.OnNewConversation(notice);
            Debug.Log($"[Customer] 新会话来了，userId={notice.userId}，userName={notice.userName}");
        }
        /// <summary>
        /// LoginHub Broadcast 数据
        /// </summary>
        [Serializable]
        public class LoginBroadcastData
        {
            public string userName;
            public string avatarUrl;
            public int level;
            public int vipLevel;
            public string message;
            public long time;
        }

        /// <summary>
        /// LoginHub KillAnnouncement 数据（全局击杀公告）
        /// </summary>
        [Serializable]
        public class KillAnnouncementData
        {
            /// <summary>公告文本（服务端已拼接：恭喜玩家*****在风雷之渊 高级场捕获 人鱼公主*2000倍 150000000大奖）</summary>
            public string text;
            /// <summary>玩家名（已脱敏，全部替换为*）</summary>
            public string userName;
            /// <summary>游戏类型名（如：风雷之渊）</summary>
            public string gameTypeName;
            /// <summary>房间名（如：高级场）</summary>
            public string roomName;
            /// <summary>鱼名称（如：人鱼公主）</summary>
            public string fishName;
            /// <summary>炮台倍数</summary>
            public int multiple;
            /// <summary>获得金币</summary>
            public long gold;
            /// <summary>时间戳（Unix秒）</summary>
            public long time;
        }

        /// <summary>
        /// LoginHub AssetUpdated 数据
        /// </summary>
        [Serializable]
        public class LoginAssetData
        {
            public int currencyType;
            public int changeType;
            public long amount;
            public long newGold;
            public int newDiamond;
            public string source;
            public string remark;
        }

        /// <summary>
        /// LoginHub BackpackUpdated 数据
        /// </summary>
        [Serializable]
        public class LoginBackpackData
        {
            public string action;
            public string propNumber;
            public int count;
            public List<object> props;
        }

        /// <summary>
        /// LoginHub NewEmail 数据
        /// </summary>
        [Serializable]
        public class LoginNewEmailData
        {
            public string title;
            public string emailId;
        }
    }
}

// end namespace