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

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

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

        private void Awake()
        {
            if (_runner == null) _runner = gameObject.AddComponent<NetworkRunner>();
            DontDestroyOnLoad(gameObject);
        }

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

        public async Task StartLobby()
        {
            if (_runner == null) _runner = gameObject.AddComponent<NetworkRunner>();
            _runner.ProvideInput = true;
            _runner.AddCallbacks(this);
            var result = await _runner.JoinSessionLobby(SessionLobby.ClientServer);
            if (!result.Ok) Debug.LogError($"Failed to join lobby: {result.ShutdownReason}");
        }

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

            // Sử dụng SessionProperties để lưu mật khẩu
            var customProps = new Dictionary<string, SessionProperty>();
            if (!string.IsNullOrEmpty(password))
            {
                customProps.Add("pw", password);
            }

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

            if (!result.Ok)
            {
                Debug.LogError($"Failed to start host: {result.ShutdownReason}");
                OnJoinFailedEvent?.Invoke();
            }
        }

        public async Task StartClient(string sessionName, string password = null)
        {
            OnJoinStartedEvent?.Invoke();

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

            if (!result.Ok)
            {
                Debug.LogError($"Failed to join client: {result.ShutdownReason}");
                OnJoinFailedEvent?.Invoke();
            }
        }

        [SerializeField] private NetworkPrefabRef _playerPrefab;
        private Dictionary<PlayerRef, NetworkObject> _spawnedCharacters = new Dictionary<PlayerRef, NetworkObject>();

        public void OnPlayerJoined(NetworkRunner runner, PlayerRef player)
        {
            if (runner.IsServer)
            {
                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);
            }

            if (player == runner.LocalPlayer)
            {
                var pdm = FindFirstObjectByType<_PlayerDataManager>();
                if (pdm != null)
                {
                    var metaData = new _PlayerMetaData()
                    {
                        Name = LocalPlayerProfile.Name,
                        Role = LocalPlayerProfile.Role,
                    };
                    pdm.RPC_UpdatePlayerMetaData(player, metaData);
                }
            }
        }

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

        public void OnShutdown(NetworkRunner runner, ShutdownReason shutdownReason)
        {
            OnShutdownEvent?.Invoke(shutdownReason.ToString());
        }

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

        public void OnInput(NetworkRunner runner, NetworkInput input)
        {
            var data = new _PlayerInputData();
            data.direction = Input.GetAxis("Vertical");
            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) { }
        public void OnSceneLoadStart(NetworkRunner runner) { }
    }
}