// SynchronisationAgrandissement.cs

using UnityEngine;
using Mirror;
using System.Collections.Generic;

/// <summary>
/// Singleton NetworkBehaviour qui synchronise les agrandissements de salle entre
/// le serveur dedicated et tous les clients.
///
/// Pattern :
///   1. Un client clique [E] sur un panneau d'agrandissement
///      -> AgrandissementSalle.DemanderAgrandir() trouve le singleton et appelle CmdAgrandir(id)
///   2. Cote serveur, CmdAgrandir valide (pas deja agrandi) et diffuse RpcLancerAgrandissement(id)
///   3. Chaque client (+ serveur) recoit le Rpc et execute l'animation locale d'Agrandir()
///      en parallele. Tous voient la meme animation car les parametres sont identiques.
///   4. Un client qui rejoint en cours de partie recoit la SyncList des agrandissements deja
///      faits et les rejoue instantanement (sans animation).
///
/// A placer : en composant sur le GameObject du NetworkManager (ou tout objet avec
/// NetworkIdentity configure pour exister des le demarrage reseau).
///
/// L'identifiant d'un agrandissement est "salleId_direction", ex: "1_Nord".
/// </summary>
public class SynchronisationAgrandissement : NetworkBehaviour
{
    public static SynchronisationAgrandissement Instance { get; private set; }

    // Liste synchronisee des agrandissements deja effectues
    // Format des entrees : "salleId_Direction" (ex: "1_Nord", "2_Est")
    private readonly SyncList<string> _agrandissementsEffectues = new SyncList<string>();

    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Debug.LogWarning("[SyncAgrandissement] Instance deja existante, destruction de ce duplicata");
            Destroy(this);
            return;
        }
        Instance = this;
    }

    private void OnDestroy()
    {
        if (Instance == this) Instance = null;
    }

    // ============================================================
    // CLIENT : appel par AgrandissementSalle.DemanderAgrandir()
    // ============================================================

    /// <summary>
    /// Appele par un client qui veut agrandir. Envoie la demande au serveur.
    /// En mode solo (pas de Mirror actif), execute directement localement.
    /// </summary>
    public void DemanderAgrandissement(int salleId, string direction)
    {
        string id = ConstruireId(salleId, direction);

        // Mode solo (pas de serveur Mirror demarre) : execution directe locale
        if (!NetworkServer.active && !NetworkClient.active)
        {
            Debug.Log($"[SyncAgrandissement] Mode solo, execution locale directe : {id}");
            ExecuterAgrandissementLocal(salleId, direction, false);
            return;
        }

        // Mode multi : Cmd vers serveur
        // Il faut que le client ait authority. On passe par le player local qui
        // porte ce role, ou directement si on est serveur nous-meme.
        if (NetworkServer.active)
        {
            // Host ou dedicated : on est serveur, on peut traiter directement
            TraiterDemandeServeur(salleId, direction);
        }
        else if (NetworkClient.active && NetworkClient.connection != null)
        {
            // Client pur : on doit passer par un PlayerBridge qui porte isLocalPlayer
            PlayerAgrandissementBridge bridge = TrouverBridgeLocal();
            if (bridge != null)
            {
                bridge.CmdDemanderAgrandissement(salleId, direction);
            }
            else
            {
                Debug.LogError("[SyncAgrandissement] Aucun PlayerAgrandissementBridge trouve sur le joueur local !");
            }
        }
    }

    // ============================================================
    // SERVEUR : validation + broadcast
    // ============================================================

    /// <summary>
    /// Appele cote serveur (soit par un host qui joue, soit par le bridge d'un client).
    /// Valide et diffuse aux clients.
    /// </summary>
    [Server]
    public void TraiterDemandeServeur(int salleId, string direction)
    {
        string id = ConstruireId(salleId, direction);

        // Validation
        if (_agrandissementsEffectues.Contains(id))
        {
            Debug.LogWarning($"[SyncAgrandissement] Demande refusee, deja agrandi : {id}");
            return;
        }

        // Enregistrer dans la liste synchronisee (pour rejoin)
        _agrandissementsEffectues.Add(id);
        Debug.Log($"[SyncAgrandissement] Agrandissement valide : {id} (total : {_agrandissementsEffectues.Count})");

        // Diffuser a tous les clients (le host le recoit aussi)
        RpcLancerAgrandissement(salleId, direction);
    }

    // ============================================================
    // CLIENTS : reception du Rpc
    // ============================================================

    [ClientRpc]
    private void RpcLancerAgrandissement(int salleId, string direction)
    {
        Debug.Log($"[SyncAgrandissement] Rpc recu, execution agrandissement : salle {salleId} direction {direction}");
        ExecuterAgrandissementLocal(salleId, direction, false);
    }

    // ============================================================
    // REJOIN : un nouveau client rejoue l'etat actuel
    // ============================================================

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

        // Ne pas rejouer sur le host (il est deja a jour, c'est lui le serveur)
        if (NetworkServer.active) return;

        // Le SyncList n'est pas forcement deja rempli a ce moment-la.
        // On se branche sur ses callbacks et on rejoue les entrees existantes.
        _agrandissementsEffectues.Callback += OnAgrandissementsListChanged;

        // Rejouer immediatement les entrees deja presentes
        if (_agrandissementsEffectues.Count > 0)
        {
            Debug.Log($"[SyncAgrandissement] Client rejoint : rejeu de {_agrandissementsEffectues.Count} agrandissement(s) passe(s)");
            foreach (string id in _agrandissementsEffectues)
            {
                RejouerInstantane(id);
            }
        }
    }

    public override void OnStopClient()
    {
        base.OnStopClient();
        _agrandissementsEffectues.Callback -= OnAgrandissementsListChanged;
    }

    private void OnAgrandissementsListChanged(SyncList<string>.Operation op, int index, string oldItem, string newItem)
    {
        // On ignore les changements qui arrivent par le flux normal (deja gere par Rpc)
        // Ce callback ne sert qu'au cas ou la SyncList est modifiee avant que le client recoive
        // le Rpc correspondant (race condition rare). Dans ce cas on rejoue aussi.
        // En pratique on s'en remet surtout au rejeu initial dans OnStartClient().
    }

    private void RejouerInstantane(string id)
    {
        int salleId;
        string direction;
        if (!DecomposerId(id, out salleId, out direction))
        {
            Debug.LogWarning($"[SyncAgrandissement] Id mal forme : {id}");
            return;
        }
        ExecuterAgrandissementLocal(salleId, direction, true);
    }

    // ============================================================
    // EXECUTION LOCALE (cote serveur ET cote client)
    // ============================================================

    /// <summary>
    /// Execute l'agrandissement sur l'instance locale : trouve le bon mur et lance Agrandir().
    /// Si instantane=true, skip les animations (pour rejoin).
    /// </summary>
    private void ExecuterAgrandissementLocal(int salleId, string direction, bool instantane)
    {
        AgrandissementSalle mur = TrouverMurAgrandissement(salleId, direction);
        if (mur == null)
        {
            Debug.LogWarning($"[SyncAgrandissement] Mur introuvable : salle {salleId} direction {direction}");
            return;
        }

        if (mur.estAgrandi || mur.enAnimation)
        {
            Debug.Log($"[SyncAgrandissement] Agrandissement deja lance ou termine localement, skip");
            return;
        }

        mur.AgrandirLocal(instantane);
    }

    private AgrandissementSalle TrouverMurAgrandissement(int salleId, string direction)
    {
        AgrandissementSalle.DirectionAgrandissement dirEnum;
        if (!System.Enum.TryParse(direction, out dirEnum)) return null;

        AgrandissementSalle[] tous = FindObjectsOfType<AgrandissementSalle>();
        foreach (var a in tous)
        {
            if (a.direction != dirEnum) continue;
            SalleDatacenter salle = FindObjectOfType<SalleDatacenter>();
            if (salle == null) continue;
            if (salle.salleId == salleId) return a;
        }

        // Fallback : si aucun salleId ne matche (salle mono, pas encore enregistree
        // par le GestionnaireMultiSalles au moment de l'appel), on renvoie n'importe
        // quel mur dans la bonne direction.
        foreach (var a in tous)
        {
            if (a.direction == dirEnum) return a;
        }

        return null;
    }

    private PlayerAgrandissementBridge TrouverBridgeLocal()
    {
        PlayerAgrandissementBridge[] tous = FindObjectsOfType<PlayerAgrandissementBridge>();
        foreach (var b in tous)
        {
            if (b.isLocalPlayer) return b;
        }
        return null;
    }

    // ============================================================
    // HELPERS ID
    // ============================================================

    private static string ConstruireId(int salleId, string direction) => $"{salleId}_{direction}";

    private static bool DecomposerId(string id, out int salleId, out string direction)
    {
        salleId = -1;
        direction = "";
        if (string.IsNullOrEmpty(id)) return false;
        int sep = id.IndexOf('_');
        if (sep <= 0 || sep >= id.Length - 1) return false;
        if (!int.TryParse(id.Substring(0, sep), out salleId)) return false;
        direction = id.Substring(sep + 1);
        return true;
    }
}

/// <summary>
/// Bridge Mirror : composant a ajouter au prefab du joueur pour qu'il puisse
/// envoyer une Cmd d'agrandissement vers le serveur (car les [Command] ne peuvent
/// etre appelees que depuis un NetworkBehaviour porte par le joueur local).
/// </summary>
public class PlayerAgrandissementBridge : NetworkBehaviour
{
    [Command]
    public void CmdDemanderAgrandissement(int salleId, string direction)
    {
        if (SynchronisationAgrandissement.Instance == null)
        {
            Debug.LogError("[PlayerAgrandissementBridge] Instance SynchronisationAgrandissement introuvable cote serveur !");
            return;
        }

        SynchronisationAgrandissement.Instance.TraiterDemandeServeur(salleId, direction);
    }
}