using System.Collections;
using System.Collections.Generic;
using Unity.Multiplayer.Samples.BossRoom;
using UnityEngine;
using Unity.Netcode;

public class ScoreManager : NetworkBehaviour
{
    public static ScoreManager Instance { get; private set; }

    public Dictionary<ulong, int> playerScores = new Dictionary<ulong, int>();
    public Dictionary<ulong, string> playerNames = new Dictionary<ulong, string>();

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

    public override void OnNetworkSpawn()
    {
        if (IsServer)
        {
            //foreach (var clientId in NetworkManager.Singleton.ConnectedClientsIds)
            //{
            //    //InitializePlayerScoreServerRpc(clientId, $"Player_{clientId}");
            //    InitializePlayerScoreServerRpc(clientId, player");
            //}
            StartCrowPenaltyCoroutineServerRpc();
        }
    }

    [ServerRpc(RequireOwnership = false)]
    public void InitializePlayerScoreServerRpc(ulong ownerClientId, string name)
    {
        if (!playerScores.ContainsKey(ownerClientId))
        {
            playerScores[ownerClientId] = 200;
            playerNames[ownerClientId] = name;

            Debug.Log($"[ScoreManager] Player {ownerClientId} initialized with a starting score of 200 and name '{name}'.");
            Scoreboard.instance.ScoreBoardItemInitializer(ownerClientId, playerScores[ownerClientId], name);
            UpdatePlayerScoreClientRpc(ownerClientId, 200);
        }
        else
        {
            Debug.LogWarning($"[ScoreManager] Player {ownerClientId} already initialized.");
        }
    }

    public void UpdatePlayerScore(ulong ownerClientId, int newScore)
    {
        if (playerScores.ContainsKey(ownerClientId))
        {
            playerScores[ownerClientId] = newScore;
            Debug.Log($"[ScoreManager] Updating Player {ownerClientId} score to {newScore}.");
            UpdatePlayerScoreClientRpc(ownerClientId, newScore);
        }
        else
        {
            Debug.LogError($"[ScoreManager] No entry found for Player {ownerClientId}. Cannot update score.");
        }
    }

    [ClientRpc]
    public void UpdatePlayerScoreClientRpc(ulong ownerClientId, int newScore)
    {
        if (playerNames.ContainsKey(ownerClientId))
        {
            string playerName = playerNames[ownerClientId];
            Debug.Log($"[ScoreManager] Received score update for Player {ownerClientId} (Name: {playerName}): {newScore}");
            Scoreboard.instance.ScoreBoardUpdater(playerName, newScore);
        }
        else
        {
            Debug.LogError($"[ScoreManager] Player name not found for Player {ownerClientId}. Cannot update scoreboard.");
        }
    }

    public void AddPlayerScore(ulong ownerClientId, int scoreToAdd)
    {
        if (playerScores.ContainsKey(ownerClientId))
        {
            playerScores[ownerClientId] += scoreToAdd;
            UpdatePlayerScore(ownerClientId, playerScores[ownerClientId]);
        }
    }

    public void SubtractPlayerScore(ulong ownerClientId, int scoreToSubtract)
    {
        if (playerScores.ContainsKey(ownerClientId))
        {
            int newScore = Mathf.Max(0, playerScores[ownerClientId] - scoreToSubtract);
            UpdatePlayerScore(ownerClientId, newScore);
        }
    }

    [ServerRpc]
    public void StartCrowPenaltyCoroutineServerRpc()
    {
        StartCoroutine(ApplyCrowPenaltyCoroutine());
    }

    private IEnumerator ApplyCrowPenaltyCoroutine()
    {
        yield return new WaitUntil(() => PlatformManager.Instance != null && PlatformManager.Instance.AreAllPlatformsOccupied());

        while (true)
        {
            foreach (var entry in playerScores)
            {
                ulong ownerClientId = entry.Key;
                int currentScore = entry.Value;

                if (CrowManager.Instance != null && CrowManager.Instance.GetCurrentCrow().OwnerClientId == ownerClientId)
                {
                    int newScore = currentScore - 2;
                    SubtractPlayerScore(ownerClientId, 2);
                    Debug.Log($"[ScoreManager] Applied crow penalty to Player {ownerClientId}. New score: {newScore}");
                }
            }
            yield return new WaitForSeconds(5f);
        }
    }
}


//using System.Collections;
//using System.Collections.Generic;
//using Unity.Multiplayer.Samples.BossRoom;
//using UnityEngine;
//using Unity.Netcode;

//public class ScoreManager : NetworkBehaviour
//{
//    public static ScoreManager Instance { get; private set; }

//    public Dictionary<ulong, int> playerScores = new Dictionary<ulong, int>();
//    public Dictionary<ulong, string> playerNames = new Dictionary<ulong, string>();

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

//    public override void OnNetworkSpawn()
//    {
//        if (IsServer)
//        {
//            StartCrowPenaltyCoroutineServerRpc();
//        }
//    }

//    [ServerRpc(RequireOwnership = false)]
//    public void InitializePlayerScoreServerRpc(ulong ownerClientId,string name)
//    {
//        if (!playerScores.ContainsKey(ownerClientId))
//        {
//            playerScores[ownerClientId] = 200;
//            Debug.Log($"[ScoreManager] Player {ownerClientId} initialized with a starting score of 200.");
//            UpdatePlayerScoreClientRpc(ownerClientId, 200);
//            playerNames[ownerClientId]= name;

//            Scoreboard.instance.ScoreBoardItemInitializer(ownerClientId, playerScores[ownerClientId],name);

//        }
//        else
//        {
//            Debug.LogWarning($"[ScoreManager] Player {ownerClientId} already initialized.");
//        }
//    }


//    public void UpdatePlayerScore(ulong ownerClientId, int newScore)
//    {
//        if (playerScores.ContainsKey(ownerClientId))
//        {
//            playerScores[ownerClientId] = newScore;
//            Debug.Log($"[ScoreManager] Updating Player {ownerClientId} score to {newScore}.");
//            UpdatePlayerScoreClientRpc(ownerClientId, newScore);
//        }
//        else
//        {
//            Debug.LogError($"[ScoreManager] No entry found for Player {ownerClientId}. Cannot update score.");
//        }
//    }

//    public void AddPlayerScore(ulong ownerClientId, int newScore)
//    {
//        if (playerScores.ContainsKey(ownerClientId))
//        {
//            playerScores[ownerClientId] += newScore;
//            Debug.Log($"[ScoreManager] Updating Player {ownerClientId} score to {playerScores[ownerClientId]}.");
//            UpdatePlayerScoreClientRpc(ownerClientId, playerScores[ownerClientId]);
//        }
//        else
//        {
//            Debug.LogError($"[ScoreManager] No entry found for Player {ownerClientId}. Cannot update score.");
//        }
//    }

//    public void SubtractPlayerScore(ulong ownerClientId, int scoreToSubtract)
//    {
//        if (playerScores.ContainsKey(ownerClientId))
//        {
//            int value = Mathf.Max(0, playerScores[ownerClientId] - scoreToSubtract);
//            playerScores[ownerClientId] = value;
//            Debug.Log($"[ScoreManager] Updating Player {ownerClientId} score to {playerScores[ownerClientId]}.");
//            UpdatePlayerScoreClientRpc(ownerClientId, playerScores[ownerClientId]);
//        }
//        else
//        {
//            Debug.LogError($"[ScoreManager] No entry found for Player {ownerClientId}. Cannot update score.");
//        }
//    }


//    public int GetPlayerScore(ulong ownerClientId)
//    {
//        if (playerScores.TryGetValue(ownerClientId, out var score))
//        {
//            return score;
//        }
//        Debug.LogError($"[ScoreManager] No entry found for Player {ownerClientId}.");
//        return 0; // Default score
//    }

//    [ServerRpc]
//    public void StartCrowPenaltyCoroutineServerRpc()
//    {
//        StartCoroutine(ApplyCrowPenaltyCoroutine());
//    }

//    private IEnumerator ApplyCrowPenaltyCoroutine()
//    {
//        yield return new WaitUntil(() => PlatformManager.Instance != null && PlatformManager.Instance.AreAllPlatformsOccupied());
//        while (true)
//        {
//            var modifications = new List<KeyValuePair<ulong, int>>();

//            foreach (var entry in playerScores)
//            {
//                var ownerClientId = entry.Key;
//                var score = entry.Value;

//                // Check if the player is the crow
//                if (CrowManager.Instance != null && CrowManager.Instance.GetCurrentCrow().OwnerClientId == ownerClientId)
//                {
//                    var newScore = score - 2;
//                    modifications.Add(new KeyValuePair<ulong, int>(ownerClientId, newScore));
//                    Debug.Log($"[ScoreManager] Applied crow penalty to Player {ownerClientId}. New score: {newScore}");
//                }
//            }

//            // Apply the modifications after the iteration
//            foreach (var modification in modifications)
//            {
//                UpdatePlayerScore(modification.Key, modification.Value);
//            }

//            // Wait for the next penalty application
//            yield return new WaitForSeconds(5f);
//        }
//    }

//    [ClientRpc]
//    public void UpdatePlayerScoreClientRpc(ulong ownerClientId, int newScore)
//    {
//        Debug.Log($"[ScoreManager] Received score update for Player {ownerClientId}: {newScore}");
//        Scoreboard.instance.ScoreBoardUpdater(playerNames[ownerClientId], newScore);

//        var playerScoreComponent = FindPlayerScoreComponent(ownerClientId);
//        if (playerScoreComponent != null)
//        {
//            playerScoreComponent.UpdateScore(newScore);
//        }
//        else
//        {
//            Debug.LogError($"[ScoreManager] Could not find PlayerScoreComponent for Player {ownerClientId}");
//        }
//    }


//    private PlayerScoreComponent FindPlayerScoreComponent(ulong ownerClientId)
//    {
//        foreach (var scoreComponent in FindObjectsOfType<PlayerScoreComponent>())
//        {
//            if (scoreComponent.OwnerClientId == ownerClientId)
//            {
//                return scoreComponent;
//            }
//        }
//        Debug.LogError($"[ScoreManager] Could not find PlayerScoreComponent for Player {ownerClientId}");
//        return null;
//    }
//}