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

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;


        private GamePlayerSo _playerDataSo;

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


        public void SetupCamera()
        {
            playerCamera = GetComponentInChildren<Camera>();
            if (playerCamera == null)
            {
                Debug.LogError("No camera found for player");
                return;
            }

            playerCamera.enabled = IsOwner;
            if (IsOwner)
            {
                Camera.main.gameObject.SetActive(false);
                playerCamera.tag = "MainCamera";
            }
        }


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

            // reset player managers
            // _playerManagers.Clear();

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

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

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

            Debug.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)
                RegisterPlayer();
        }

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

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

        [ServerRpc(RequireOwnership = false)]
        private void RegisterPlayer()
        {
            // Your existing registration code...
            Debug.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;
            }
            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()
        {
            // get player data from GameManager
            // Debug.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)
            {
                Debug.Log("PlayerManager: " + playerManager.Key);
                Debug.Log("PlayerManager.IsOwner: " + playerManager.Value.IsOwner);
                Debug.Log("PlayerManager.IsClientInitialized: " + playerManager.Value.IsClientInitialized);
                Debug.Log("PlayerManager.IsServerInitialized: " + playerManager.Value.IsServerInitialized);
            }
        }

        public Camera GetPlayerCamera()
        {
            return playerCamera;
        }

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

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

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

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

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

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

    if (IsOwner)
    {
        if (_playerData.Value == null)
        {
            Debug.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();

        Debug.Log("PlayerManager RegisterPlayer");

        if (Owner == null) Debug.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:
                    Debug.Log("Getting Inventory Manager");
                    return inventoryManager;
                case SlotType.Toolbar:
                    Debug.Log("Getting Toolbar Manager");
                    return toolbarManager;
                case SlotType.Equipment:
                    Debug.Log("Getting Equipment Manager");
                    return equipmentManager;
                case SlotType.Box:
                    Debug.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)
        {
            Debug.Log("Getting SlotType " + slotType + " / " + slotId);
            var manager = GetManagerBySlotType(slotType);
            if (manager == null) Debug.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)
{
    Debug.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;
// }
    }
}