UnityTowerDefense/Assets/_Project/Scripts/Gameplay/Draft/PlayerDraft.cs

// Assets/_Project/Scripts/Gameplay/Draft/PlayerDraft.cs
using System.Collections.Generic;
using Unity.Netcode;
using UnityEngine;

namespace TD.Gameplay.Draft
{
    /// <summary>
    /// Per-player draft state — the set of <see cref="DraftOption"/>s currently offered to
    /// one player. Lives on the Player prefab alongside <see cref="PlayerTowerDeck"/>,
    /// <see cref="PlayerGoldManager"/>, etc.
    /// </summary>
    /// <remarks>
    /// <para><b>Offered set.</b> <see cref="currentOptionIds"/> holds the DraftOptionIds
    /// the player is choosing between (typically 3). Empty means no active draft. The
    /// owning client renders cards from these ids; the server reads them to validate a pick.</para>
    ///
    /// <para><b>Authority.</b> The server offers (<see cref="ServerOffer"/>), resolves
    /// (<see cref="ServerResolve"/> / <see cref="ServerAutoResolve"/>), and applies the
    /// chosen option. The owning client only sends intent via
    /// <see cref="RequestPickRpc"/>.</para>
    ///
    /// <para><b>The paid reroll is disabled</b> for the 2.0 MVP — see the commented-out block at
    /// the bottom of this file for why it was kept rather than removed.</para>
    ///
    /// <para><b>Generation</b> lives in <see cref="DraftService"/>; this component is just
    /// the replicated state + the pick/buy entry points.</para>
    /// </remarks>
    public class PlayerDraft : NetworkBehaviour
    {
        // ----- Static registry (mirrors PlayerGoldManager / PlayerTowerDeck) -----

        private static readonly Dictionary<ulong, PlayerDraft> s_byClientId
            = new Dictionary<ulong, PlayerDraft>();

        public static PlayerDraft GetForClient(ulong clientId)
        {
            s_byClientId.TryGetValue(clientId, out var draft);
            return draft;
        }

        public static PlayerDraft Local
        {
            get
            {
                var nm = NetworkManager.Singleton;
                if (nm == null || !nm.IsClient) return null;
                return GetForClient(nm.LocalClientId);
            }
        }

        // ----- Networked state --------------------------------------------

        // The DraftOptionIds currently offered to this player. Empty = no active draft.
        private NetworkList<int> currentOptionIds;

        /// <summary>Fired on every peer when the offered set changes (offered, picked,
        /// cleared). The HUD subscribes to show/hide/rebuild the draft overlay.</summary>
        public event System.Action OnDraftChanged;

        private void Awake()
        {
            currentOptionIds = new NetworkList<int>();
        }

        public override void OnNetworkSpawn()
        {
            s_byClientId[OwnerClientId] = this;
            currentOptionIds.OnListChanged += HandleListChanged;
        }

        public override void OnNetworkDespawn()
        {
            currentOptionIds.OnListChanged -= HandleListChanged;
            if (s_byClientId.TryGetValue(OwnerClientId, out var registered) && registered == this)
                s_byClientId.Remove(OwnerClientId);
        }

        private void HandleListChanged(NetworkListEvent<int> _) => OnDraftChanged?.Invoke();

        // ----- Read API ---------------------------------------------------

        /// <summary>True if the player currently has options to choose from.</summary>
        public bool HasActiveDraft => currentOptionIds.Count > 0;

        public int OptionCount => currentOptionIds.Count;

        public int GetOptionId(int index) => currentOptionIds[index];

        private bool IsOffered(int optionId)
        {
            for (int i = 0; i < currentOptionIds.Count; i++)
                if (currentOptionIds[i] == optionId) return true;
            return false;
        }

        // ----- Server: offer / resolve ------------------------------------

        /// <summary>Server-only: replace the offered set with <paramref name="ids"/>.</summary>
        public void ServerOffer(IReadOnlyList<int> ids)
        {
            if (!IsServer) return;
            currentOptionIds.Clear();
            if (ids == null) return;
            for (int i = 0; i < ids.Count; i++)
                currentOptionIds.Add(ids[i]);
        }

        /// <summary>
        /// Server-only: apply one of the currently-offered options by id, then clear the
        /// draft. No-op (returns false) if the id wasn't offered or the option fails to apply.
        /// </summary>
        private bool ServerResolve(int optionId)
        {
            if (!IsServer) return false;
            if (!IsOffered(optionId)) return false;

            var option = DraftPool.Instance != null ? DraftPool.Instance.Get(optionId) : null;
            bool applied = option != null && option.ServerApply(OwnerClientId);
            if (!applied)
                Debug.LogWarning($"[PlayerDraft] Option {optionId} could not be applied for " +
                                 $"client {OwnerClientId}.");

            currentOptionIds.Clear();
            return applied;
        }

        /// <summary>
        /// Server-only: if the player still has an unpicked draft, auto-resolve it by
        /// applying the first offered option. Called at prep end so a free reward is never
        /// wasted by an idle player.
        /// </summary>
        public void ServerAutoResolve()
        {
            if (!IsServer) return;
            if (currentOptionIds.Count == 0) return;
            ServerResolve(currentOptionIds[0]);
        }

        // ----- Owner → server RPCs ----------------------------------------

        /// <summary>Owning client: pick one of the offered options by id.</summary>
        [Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Owner)]
        public void RequestPickRpc(int optionId)
        {
            ServerResolve(optionId);
        }

        // ----- Extra-draft shop (DISABLED for the 2.0 MVP) --------------------
        //
        // Kept rather than deleted: the shop is expected back, but as a SHARED gold sink — the
        // whole lobby pools money toward one collective extra draft for everyone — rather than
        // the per-player reroll implemented here. When it returns, this method is the wrong shape
        // (per-player deduction, per-player offer) but the surrounding plumbing is right, so it
        // stays as the reference for what to rebuild against.
        //
        // Re-enabling this alone would also break the inter-wave barrier: DraftService.
        // AllPlayersPicked ends the draft stage the moment everyone has resolved, so a player
        // buying a roll after that point would be offered cards the sequence has already moved
        // past.
        //
        // /// <summary>
        // /// Owning client: buy a fresh roll of options for gold. Rejected if the player can't
        // /// afford it or already has an unresolved draft (resolve the current one first so a
        // /// free pick is never silently overwritten).
        // /// </summary>
        // [Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Owner)]
        // public void RequestBuyRerollRpc()
        // {
        //     if (HasActiveDraft) return; // resolve the pending draft before buying another
        //
        //     var service = DraftService.Instance;
        //     if (service == null) return;
        //
        //     var gold = PlayerGoldManager.GetForClient(OwnerClientId);
        //     int cost = service.RerollCost;
        //     if (gold == null || gold.CurrentGold < cost) return;
        //
        //     gold.DeductGold(cost);
        //     service.ServerOfferTo(OwnerClientId);
        // }
    }
}