using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Fusion;
using Fusion.Sockets;
using UnityEngine;
using OnlyScove.Scripts;

namespace Hallucinate.UI
{
    public class BasicSpawner : MonoBehaviour, INetworkRunnerCallbacks
    {
        public static BasicSpawner Instance { get; private set; }
        private NetworkRunner _runner;

        public event Action<List<SessionInfo>> OnSessionListUpdatedEvent;
        public event Action<string> OnShutdownEvent;
        public event Action OnJoinStartedEvent;
        public event Action OnJoinFailedEvent;

        [Header("Prefabs")]
        [SerializeField] private NetworkPrefabRef _playerPrefab;
        [SerializeField] private NetworkPrefabRef _playerDataManagerPrefab;

        private void Awake()
        {
            if (Instance != null && Instance != this)
            {
                Destroy(gameObject);
                return;
            }
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }

        public PlayerProfile LocalPlayerProfile { get; private set; }
        public void SetLocalPlayerProfile(PlayerProfile _profile)
        {
            LocalPlayerProfile = _profile;
        }

        private async Task EnsureRunnerExists()
        {
            if (_runner == null)
            {
                _runner = GetComponent<NetworkRunner>();
            }

            if (_runner != null && _runner.IsRunning)
            {
                await _runner.Shutdown();
            }

            if (_runner == null)
            {
                _runner = gameObject.AddComponent<NetworkRunner>();
            }

            _runner.ProvideInput = true;
            _runner.RemoveCallbacks(this);
            _runner.AddCallbacks(this);
        }

        public async Task StartLobby()
        {
            await EnsureRunnerExists();
            
            if (_runner.SessionInfo.IsValid) return;

            var result = await _runner.JoinSessionLobby(SessionLobby.ClientServer);
            if (!result.Ok) 
            {
                Debug.LogWarning($"Join lobby result: {result.ShutdownReason}. This is often normal on first run if already connecting.");
            }
        }

        public async Task<bool> StartHost(string sessionName, string displayName, string password = null)
        {
            OnJoinStartedEvent?.Invoke();

            bool sceneExists = false;
            for (int i = 0; i < UnityEngine.SceneManagement.SceneManager.sceneCountInBuildSettings; i++)
            {
                if (UnityEngine.SceneManagement.SceneUtility.GetScenePathByBuildIndex(i).Contains("Main Scene"))
                {
                    sceneExists = true;
                    break;
                }
            }

            if (!sceneExists)
            {
                Debug.LogError("CRITICAL: 'Main Scene' is NOT in Build Settings!");
                return false;
            }

            await EnsureRunnerExists();

            var customProps = new Dictionary<string, SessionProperty>();
            if (!string.IsNullOrEmpty(password))
            {
                customProps.Add("pw", password);
            }
            customProps.Add("rn", displayName);

            var result = await _runner.StartGame(new StartGameArgs()
            {
                GameMode = GameMode.Host,
                SessionName = sessionName,
                SessionProperties = customProps,
                PlayerCount = 2,
                SceneManager = gameObject.GetComponent<NetworkSceneManagerDefault>() ?? gameObject.AddComponent<NetworkSceneManagerDefault>()
            });

            if (result.Ok)
            {
                if (_runner.IsServer && _playerDataManagerPrefab.IsValid)
                {
                    if (FindFirstObjectByType<PlayerDataManager>() == null)
                    {
                        _runner.Spawn(_playerDataManagerPrefab, Vector3.zero, Quaternion.identity, null);
                    }
                }
                return true;
            }
            else
            {
                Debug.LogError($"Fusion StartHost Failed: {result.ShutdownReason}.");
                OnJoinFailedEvent?.Invoke();
                return false;
            }
        }

        public async Task<bool> StartClient(string sessionName, string password = null)
        {
            OnJoinStartedEvent?.Invoke();
            await EnsureRunnerExists();

            var result = await _runner.StartGame(new StartGameArgs()
            {
                GameMode = GameMode.Client,
                SessionName = sessionName,
                SceneManager = gameObject.GetComponent<NetworkSceneManagerDefault>() ?? gameObject.AddComponent<NetworkSceneManagerDefault>()
            });

            if (result.Ok)
            {
                return true;
            }
            else
            {
                Debug.LogError($"Fusion StartClient Failed: {result.ShutdownReason}");
                OnJoinFailedEvent?.Invoke();
                return false;
            }
        }

        private Dictionary<PlayerRef, NetworkObject> _spawnedCharacters = new Dictionary<PlayerRef, NetworkObject>();

        public void OnPlayerJoined(NetworkRunner runner, PlayerRef player)
        {
            if (player == runner.LocalPlayer)
            {
                SendLocalMetaData(player);
            }
        }

        private async void SendLocalMetaData(PlayerRef player)
        {
            PlayerDataManager pdm = null;
            int retries = 0;
            while (pdm == null && retries < 20)
            {
                pdm = FindFirstObjectByType<PlayerDataManager>();
                if (pdm != null) break;
                await Task.Delay(500);
                retries++;
            }

            if (pdm != null)
            {
                string playerName = LocalPlayerProfile != null ? LocalPlayerProfile.Name : "Player " + player.PlayerId;
                
                // Thêm hậu tố (HOST) nếu là server để dễ phân biệt
                if (_runner.IsServer) playerName += " (HOST)";

                _Role playerRole = _Role.Seeker;

                var metaData = new _PlayerMetaData()
                {
                    Name = playerName,
                    Role = playerRole,
                    IsReady = false
                };
                pdm.RPC_UpdatePlayerMetaData(player, metaData);
            }
            else
            {
                Debug.LogError("[BasicSpawner] Could not find PlayerDataManager after retries. Data will not sync.");
            }
        }

        public void StartGame()
        {
            if (_runner != null && _runner.IsServer)
            {
                _runner.LoadScene("Main Scene");
            }
        }

        public void OnPlayerLeft(NetworkRunner runner, PlayerRef player)
        {
            if (_spawnedCharacters.TryGetValue(player, out NetworkObject networkObject))
            {
                runner.Despawn(networkObject);
                _spawnedCharacters.Remove(player);
            }

            if (runner.IsServer && player == runner.LocalPlayer) 
            {
                runner.Shutdown();
            }
        }

        public void OnShutdown(NetworkRunner runner, ShutdownReason shutdownReason)
        {
            Debug.LogWarning($"[Fusion] Shutdown occurred. Reason: {shutdownReason}");
            OnShutdownEvent?.Invoke(shutdownReason.ToString());
            
            if (UIManager.Instance != null)
            {
                UIManager.Instance.OnBackToMenu();
            }
        }

        public void OnSessionListUpdated(NetworkRunner runner, List<SessionInfo> sessionList)
        {
            OnSessionListUpdatedEvent?.Invoke(sessionList);
        }

        public void OnInput(NetworkRunner runner, NetworkInput input)
        {
            var data = new PlayerInputData();
            if (PlayerStateMachine.Local != null && PlayerStateMachine.Local.Input != null)
            {
                data.Direction = PlayerStateMachine.Local.Input.MoveInput;
                data.sprint = PlayerStateMachine.Local.Input.IsSprintHeld;
                if (PlayerStateMachine.Local.Cam != null)
                    data.rot = PlayerStateMachine.Local.Cam.PlanarRotation;
            }
            input.Set(data);
        }

        public void OnConnectedToServer(NetworkRunner runner) { }
        public void OnDisconnectedFromServer(NetworkRunner runner, NetDisconnectReason reason) { }
        public void OnConnectRequest(NetworkRunner runner, NetworkRunnerCallbackArgs.ConnectRequest request, byte[] token) { }
        public void OnConnectFailed(NetworkRunner runner, NetAddress remoteAddress, NetConnectFailedReason reason) { }
        public void OnUserSimulationMessage(NetworkRunner runner, SimulationMessagePtr message) { }
        public void OnReliableDataReceived(NetworkRunner runner, PlayerRef player, ReliableKey key, ArraySegment<byte> data) { }
        public void OnReliableDataProgress(NetworkRunner runner, PlayerRef player, ReliableKey key, float progress) { }
        public void OnInputMissing(NetworkRunner runner, PlayerRef player, NetworkInput input) { }
        public void OnObjectExitAOI(NetworkRunner runner, NetworkObject obj, PlayerRef player) { }
        public void OnObjectEnterAOI(NetworkRunner runner, NetworkObject obj, PlayerRef player) { }
        public void OnCustomAuthenticationResponse(NetworkRunner runner, Dictionary<string, object> data) { }
        public void OnHostMigration(NetworkRunner runner, HostMigrationToken hostMigrationToken) { }
        
        public void OnSceneLoadDone(NetworkRunner runner)
        {
            string currentSceneName = UnityEngine.SceneManagement.SceneManager.GetActiveScene().name;
            if (runner.IsServer && currentSceneName == "Main Scene")
            {
                foreach (var player in runner.ActivePlayers)
                {
                    Vector2 spawnPosition = (player == runner.LocalPlayer) ? new Vector2(-8, 0) : new Vector2(8, 0);
                    var networkPlayerObject = runner.Spawn(_playerPrefab, spawnPosition, Quaternion.identity, player);
                    _spawnedCharacters.Add(player, networkPlayerObject);
                }
            }
            // Removed incorrect UI transition for Lobby/Menu scenes to allow LobbyController to manage its state.
            // The original logic incorrectly called UIManager.OnBackToMenu() when entering the Lobby scene,
            // causing the redirect to the Main Menu after creating a room.
            // This block ensures that only the Main Scene triggers a specific UI transition (OnGameStarted).
            // If other scenes like "Lobby" or "Menu" are loaded, no automatic transition is forced from here,
            // letting scene-specific controllers (like LobbyController) manage their UI.
            if (currentSceneName == "Main Scene")
            {
                UIManager.Instance?.OnGameStarted();
            }
            // Removed the problematic else-if block that would incorrectly call OnBackToMenu for "Lobby" or "Menu" scenes.
        }


        public void OnSceneLoadStart(NetworkRunner runner) { }
    }
}