using System;
using System.Collections;
using System.Collections.Generic;
using Cinemachine;
using Data.ScriptableObjects;
using FishNet.Object;
using Managers.Item;
using Types;
using Types.Items;
using Types.UI;
using UnityEditor;
using UnityEngine;
using Utils;

namespace Managers
{
    // Manages a INSTANCE of a single player.
    public class PlayerManager : NetworkBehaviour
    {
        private static readonly Dictionary<int, PlayerManager> _playerManagers = new();


        [SerializeField] private InventoryManager inventoryManager;
        [SerializeField] private ToolbarManager toolbarManager;
        [SerializeField] private EquipmentManager equipmentManager;

        [SerializeField] private GameObject playerGo;

        [SerializeField] private Camera playerCamera;

        [SerializeField] private NetworkObject gameManagerPrefab;

        public bool isRegistered;
        [SerializeField] private bool _isInMenu;

        private GamePlayerSo _playerDataSo;

        private void Awake()
        {
            // _playerData.OnChange += playerData_OnChange;
            _playerDataSo = AssetDatabase.LoadAssetAtPath<GamePlayerSo>("Assets/Resources/DefaultPlayer.asset");
            _isInMenu = false;
        }

        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
        private static void ResetStaticData()
        {
            _playerManagers.Clear();
            GameLogger.Log("playerManagers dictionary has been cleared.");
        }

        public void SetInMenu()
        {
            _isInMenu = true;
        }

        public void SetNotInMenu()
        {
            _isInMenu = false;
        }

        public void SetupCamera()
        {
            var camera = GetComponentInChildren<CinemachineBrain>(true);
            if (camera == null)
            {
                GameLogger.LogError("No camera found for player");
                return;
            }

            playerCamera.enabled = IsOwner;
            if (IsOwner)
            {
                camera.gameObject.SetActive(true);
                playerCamera.tag = "MainCamera";
            }
        }


        public override void OnStartServer()
        {
            base.OnStartServer();

            if (IsServerInitialized)
            {
                GameLogger.Log("Server initialized");
                if (GameManager.Instance == null) GameLogger.Log("GameManager not found, creating new one");
                GameInit.Instance.InitializeGameManager();
            }

            if (IsClientInitialized)
            {
                // sync player data
                // _syncPlayers.DirtyAll();
                // _syncPlayers.OnChange += SyncPlayersChange;
            }
        }


        private IEnumerator WaitForServerInitialization()
        {
            while (!IsServerInitialized)
            {
                GameLogger.Log("Waiting for server to initialize...");
                yield return new WaitForSeconds(0.1f);
            }

            GameLogger.Log("Server initialized");
            GameInit.Instance.InitializeGameManager();
        }

        public override void OnStartClient()
        {
            base.OnStartClient();

            GameLogger.Log("Client started. IsServer: " + IsServerInitialized + ", IsClient: " + IsClientInitialized);

            if (IsClientInitialized && !IsServerInitialized) // This is a client-only instance
            {
                StartCoroutine(WaitForConnectionAndRegister());
            }
            else if (IsServerInitialized && IsClientInitialized) // This is the server or a host (client+server)
            {
                GameLogger.Log("Server and client initialized, registering player...");
                // GameInit.Instance.InitializeGameManager();
                RegisterPlayer();
            }
        }

        public override void OnStartNetwork()
        {
            base.OnStartNetwork();
            GameLogger.Log("PlayerManager: Network started");
        }

        private IEnumerator WaitForConnectionAndRegister()
        {
            GameLogger.Log("Waiting for connection to server...");
            while (!IsClientInitialized) yield return new WaitForSeconds(0.5f);

            GameLogger.Log("Connected to server. Registering player...");
            RegisterPlayer();
        }

        [ServerRpc(RequireOwnership = false)]
        private void RegisterPlayer()
        {
            // Your existing registration code...
            GameLogger.Log("Attempting to register player on server." + Owner.ClientId + ", IsOwner: " + IsOwner);

            var playerData = new GamePlayer(_playerDataSo)
            {
                PlayerName = "Player " + Owner.ClientId,
                ID = Guid.NewGuid(),
                ClientId = Owner.ClientId
            };

            try
            {
                GameManager.Instance.RegisterPlayerServerRpc(Owner, playerData);
                _playerManagers.Add(Owner.ClientId, this);
                isRegistered = true;
                SetupCamera();
            }
            catch (Exception e)
            {
                // replace the player manager with the new one
                _playerManagers[Owner.ClientId] = this;
                isRegistered = true;
            }
        }

        public GameObject GetPlayerGo()
        {
            return playerGo;
        }

        public GamePlayer GetPlayerData()
        {
            if (GameManager.Instance == null)
            {
                GameLogger.LogWarning("GameManager not found");
                return null;
            }

            // get player data from GameManager
            // GameLogger.Log("Getting player data for clientId: " + Owner.ClientId);
            return GameManager.Instance.GetPlayer(Owner.ClientId);
        }


        public static PlayerManager GetPlayerManager(int clientId)
        {
            PrintPlayerManagers();
            return _playerManagers[clientId];
        }

        public static void PrintPlayerManagers()
        {
            foreach (var playerManager in _playerManagers)
            {
                GameLogger.Log("PlayerManager: " + playerManager.Key);
                GameLogger.Log("PlayerManager.IsOwner: " + playerManager.Value.IsOwner);
                GameLogger.Log("PlayerManager.IsClientInitialized: " + playerManager.Value.IsClientInitialized);
                GameLogger.Log("PlayerManager.IsServerInitialized: " + playerManager.Value.IsServerInitialized);
            }
        }


        public Camera GetPlayerCamera()
        {
            return playerCamera;
        }

/*private IEnumerator WaitForClientActiveAndRegister()
{
    while (!IsClientInitialized && !IsClientStarted)
    {
        GameLogger.Log("Waiting for client to be initialized");
        yield return null;
    }

    GameLogger.Log("Client is Ready to RegisterPlayer");
    if (Owner == null) GameLogger.LogError("OwnerConnection not found");
    if (gameManager == null) gameManager = FindObjectOfType<GameManager>();
    GameLogger.Log("GameManager should be found");
    gameManager.RegisterPlayerServerRpc(Owner, _playerData.Value);
}*/

/*public override void OnStartClient()
{
    base.OnStartClient();

    if (gameManager == null)
    {
        GameLogger.Log("Trying to find GameManager");
        GameInit.Instance.InitializeGameManager();
        gameManager = FindObjectOfType<GameManager>();

        if (gameManager == null)
        {
            GameLogger.LogError("GameManager not found");
            return;
        }

        if (gameManager) GameLogger.Log("GameManager found");
    }

    if (IsOwner)
    {
        if (_playerData.Value == null)
        {
            GameLogger.LogWarning("PlayerData not found");
            // load a scriptable objects default player data
            var playerData =
                AssetDatabase.LoadAssetAtPath<GamePlayerSo>("Assets/Resources/DefaultPlayer.asset");

            _playerData.Value = new GamePlayer(playerData)
            {
                PlayerName = "Default Player"
            };
        }

        InitializeManager();

        GameLogger.Log("PlayerManager RegisterPlayer");

        if (Owner == null) GameLogger.LogError("OwnerConnection not found");

        StartCoroutine(WaitForClientActiveAndRegister());
        // gameManager.RegisterPlayerServerRpc(Owner, _playerData.Value);
        // gameManager.AddPlayer(this);
        LocalPlayerManager.Instance = this;
    }
    else
    {
        // disables other peoples character controls.
        gameObject.GetComponent<PlayerManager>().enabled = false;
        gameObject.GetComponent<PlayerController>().enabled = false;
    }
}*/

// gets manager by slot type
        public IItemManager<GameSlot> GetManagerBySlotType(SlotType slotType)
        {
            switch (slotType)
            {
                case SlotType.Inventory:
                    GameLogger.Log("Getting Inventory Manager");
                    return inventoryManager;
                case SlotType.Toolbar:
                    GameLogger.Log("Getting Toolbar Manager");
                    return toolbarManager;
                case SlotType.Equipment:
                    GameLogger.Log("Getting Equipment Manager");
                    return equipmentManager;
                case SlotType.Box:
                    GameLogger.Log("Getting Box Manager");
                    return BoxManager.Instance;
                case SlotType.Crafting:
                    break;
                case SlotType.Shop:
                    break;
                case SlotType.Quest:
                    break;
                default:
                    return null;
            }

            return null;
        }

        public GameSlot GetSlot(SlotType slotType, int slotId)
        {
            GameLogger.Log("Getting SlotType " + slotType + " / " + slotId);
            var manager = GetManagerBySlotType(slotType);
            if (manager == null) GameLogger.LogError("Manager not found");
            if (manager != null) return manager.GetSlot(slotId);
            return null;
        }

// Load save data


        public GameSlot GetActiveToolbarSlot()
        {
            return toolbarManager.GetActiveToolbarSlot();
        }


/*
[Server]
public void Initialize(GamePlayer data)
{
    GameLogger.Log("Initializing PlayerManager");
    _playerData.Value = data;
    inventoryManager.Initialize(data);
    toolbarManager.Initialize(data);
    equipmentManager.Initialize(data);
}
*/


        public InventoryManager GetInventoryManager()
        {
            if (inventoryManager != null) return inventoryManager;
            return null;
        }

        public ToolbarManager GetToolbarManager()
        {
            if (toolbarManager != null) return toolbarManager;
            return null;
        }

        public EquipmentManager GetEquipmentManager()
        {
            if (equipmentManager != null) return equipmentManager;
            return null;
        }

        public void AddItemToInventorySlot(GameItem item, int slotId)
        {
            // inventoryManager.AddItemToSlot(item, slotId);
        }

        [ServerRpc]
        public void AddItemToInventory(GameItem item)
        {
            // inventoryManager.AddItemToOpenSlot(item);
        }

// [ServerRpc]
// public void SetPlayerData(GamePlayer pd)
// {
//     playerData.Value = pd;
// }
        public object GetInMenuState()
        {
            return _isInMenu;
        }
    }
}