// Assets/_Project/Scripts/Gameplay/BuildSiteVisual.cs
using Unity.Netcode;
using UnityEngine;
using TD.Core;
using TD.Towers;
using TD.VFX;

namespace TD.Gameplay
{
    /// <summary>
    /// Visual representation of an in-flight <see cref="BuildJob"/>: a static, non-growing
    /// site marker (color-tinted by stage) plus the ground targeting reticle
    /// (<see cref="TowerDropReticle"/>) that shrinks as construction progresses. One
    /// NetworkObject per active job. Despawned when the job is cancelled or when the real
    /// <see cref="TowerInstance"/> takes its place at construction-complete, at which point
    /// <c>TowerLandingVisual</c> plays the tower's fall-from-sky arrival.
    /// </summary>
    /// <remarks>
    /// <para><b>Why a separate prefab from TowerInstance.</b> The build-site visual
    /// has different rendering (translucent green site marker), no combat,
    /// no grid-stamping (the Builder owns those state transitions), and a much
    /// shorter lifecycle. Sharing a prefab with TowerInstance would mean adding
    /// "am I real or a ghost" branching to every TowerInstance code path. Two
    /// prefabs, two responsibilities.</para>
    ///
    /// <para><b>Stage replication.</b> Stage and ConstructionStartServerTime are
    /// replicated as NetworkVariables so all peers compute identical visuals locally
    /// from <c>NetworkManager.ServerTime.TimeAsFloat</c>. Only the server writes;
    /// clients read.</para>
    ///
    /// <para><b>Visual model.</b> The site marker's material swaps by stage (queued/
    /// constructing/paused) but never grows or changes shape — construction progress is
    /// communicated entirely by the reticle shrinking, not by the marker itself.</para>
    ///
    /// <para><b>No grid stamping here.</b> Walkability and occupancy stamps are
    /// driven by the Builder (queue-time stamps occupied=true / walkable=true,
    /// construction-start stamps walkable=false, completion is unchanged because
    /// TowerInstance takes over). Adding stamping here would create double-write
    /// races with the Builder. See lessons in the project context doc.</para>
    /// </remarks>
    [RequireComponent(typeof(NetworkObject))]
    public class BuildSiteVisual : NetworkBehaviour, ISelectable
    {
        // ----- Inspector --------------------------------------------------

        [Header("Visuals")]
        [Tooltip("Renderers tinted with the queued-ghost color. Typically every " +
                 "MeshRenderer on the prefab. Auto-populated from children if empty.")]
        [SerializeField] private MeshRenderer[] tintedRenderers;

        [Tooltip("Material applied while the job is Queued (translucent green).")]
        [SerializeField] private Material queuedMaterial;

        [Tooltip("Material applied while the job is Constructing (opaque, tinted by owner).")]
        [SerializeField] private Material constructingMaterial;

        [Tooltip("Material applied while the job is Paused. Visually distinct from " +
                 "Constructing so players can tell at a glance which builds need a builder. " +
                 "Suggested: muted/grey-tinted variant of the constructing material.")]
        [SerializeField] private Material pausedMaterial;

        [Header("Drop reticle FX")]
        [Tooltip("Optional targeting-reticle effect (ground decal + beam + motes) shown for the " +
                 "life of this build. Spawned as a child on every peer and fed construction " +
                 "progress each frame so it shrinks as the tower builds, then destroyed with " +
                 "this visual at completion/cancel. Leave empty to build with no reticle.")]
        [SerializeField] private TowerDropReticle dropReticlePrefab;

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

        // Replicated owner slot for color tinting. Mirrors TowerInstance.
        private readonly NetworkVariable<PlayerSlot> ownerSlot =
            new NetworkVariable<PlayerSlot>(
                PlayerSlot.None,
                readPerm: NetworkVariableReadPermission.Everyone,
                writePerm: NetworkVariableWritePermission.Server);

        // Anchor tile (SW corner of the footprint, world-tile coords). Replicated so
        // shelved visuals are self-describing — when a player clicks one to resume,
        // the server can rebuild a BuildJob from these fields without consulting any
        // separate registry.
        private readonly NetworkVariable<Vector2Int> anchor =
            new NetworkVariable<Vector2Int>(
                Vector2Int.zero,
                readPerm: NetworkVariableReadPermission.Everyone,
                writePerm: NetworkVariableWritePermission.Server);

        // Tower type ID (index into TowerPlacementManager.towerDefinitions[]). Replicated
        // for the same self-describing reason as Anchor.
        private readonly NetworkVariable<int> towerTypeId =
            new NetworkVariable<int>(
                0,
                readPerm: NetworkVariableReadPermission.Everyone,
                writePerm: NetworkVariableWritePermission.Server);

        // Gold the player paid to queue this build. Carried on the visual so resume
        // can refund the correct amount if the player later cancels. (Cancellation
        // gesture deferred to HUD; this field is the data dependency.)
        private readonly NetworkVariable<int> goldSpent =
            new NetworkVariable<int>(
                0,
                readPerm: NetworkVariableReadPermission.Everyone,
                writePerm: NetworkVariableWritePermission.Server);

        // True iff this build site has been "shelved" — removed from its owning Builder's
        // queue and now a standalone object waiting to be resumed via right-click.
        // Shelved visuals are responsible for their own grid-state cleanup on despawn
        // (since the Builder no longer tracks them in jobIdToVisual).
        private readonly NetworkVariable<bool> isShelved =
            new NetworkVariable<bool>(
                false,
                readPerm: NetworkVariableReadPermission.Everyone,
                writePerm: NetworkVariableWritePermission.Server);

        // Current stage. Drives the site marker's material/tint swap.
        private readonly NetworkVariable<BuildStage> currentStage =
            new NetworkVariable<BuildStage>(
                BuildStage.Queued,
                readPerm: NetworkVariableReadPermission.Everyone,
                writePerm: NetworkVariableWritePermission.Server);

        // Server time at which the current Constructing run began. -1 while Queued or Paused.
        // Used together with accumulatedConstructionTime to compute total progress:
        // total = (now - constructionStartServerTime) + accumulatedConstructionTime.
        private readonly NetworkVariable<float> constructionStartServerTime =
            new NetworkVariable<float>(
                -1f,
                readPerm: NetworkVariableReadPermission.Everyone,
                writePerm: NetworkVariableWritePermission.Server);

        // Construction time accumulated across previous Constructing runs (for pause/resume).
        // 0 for jobs that have never been paused. At pause, set to the elapsed time of the
        // current run added to whatever was already accumulated.
        private readonly NetworkVariable<float> accumulatedConstructionTime =
            new NetworkVariable<float>(
                0f,
                readPerm: NetworkVariableReadPermission.Everyone,
                writePerm: NetworkVariableWritePermission.Server);

        // BuildTime is replicated rather than looked up so clients don't need to
        // resolve the TowerDefinition before they can render progress.
        // (Resolution can race with the first stage update otherwise.)
        private readonly NetworkVariable<float> buildTime =
            new NetworkVariable<float>(
                0f,
                readPerm: NetworkVariableReadPermission.Everyone,
                writePerm: NetworkVariableWritePermission.Server);

        // ----- Public accessors (read by the input controller on click) --

        // NOTE: ownership identity comes from the inherited NetworkBehaviour.OwnerClientId,
        // which is correct because we use SpawnWithOwnership in Builder.SpawnBuildSiteVisual.
        // No redundant NetworkVariable for ownership.

        /// <summary>The current build stage. Read by clients for click-target tests.</summary>
        public BuildStage CurrentStage => currentStage.Value;

        /// <summary>True iff this visual has been shelved (no longer in its Builder's queue).</summary>
        public bool IsShelved => isShelved.Value;

        /// <summary>Footprint anchor (SW corner). Used by server to rebuild a BuildJob on resume.</summary>
        public Vector2Int Anchor => anchor.Value;

        /// <summary>Tower type ID. Used by server to rebuild a BuildJob on resume.</summary>
        public int TowerTypeId => towerTypeId.Value;

        /// <summary>Gold paid for this build. Used by server to rebuild a BuildJob on resume.</summary>
        public int GoldSpent => goldSpent.Value;

        /// <summary>Accumulated construction time (across pause/resume cycles). Used on resume.</summary>
        public float AccumulatedConstructionTime => accumulatedConstructionTime.Value;

        /// <summary>
        /// Returns [0,1] normalized construction progress. Safe to call on any client.
        /// Returns 0 while Queued; freezes at accumulated fraction while Paused.
        /// </summary>
        public float ComputeProgressNormalized()
        {
            float bt = buildTime.Value;
            if (bt <= 0f) return 0f;
            float currentRunElapsed = constructionStartServerTime.Value > 0f
                ? (float)NetworkManager.Singleton.ServerTime.Time - constructionStartServerTime.Value
                : 0f;
            return Mathf.Clamp01((currentRunElapsed + accumulatedConstructionTime.Value) / bt);
        }

        // ----- ISelectable ------------------------------------------------

        /// <summary>Name shown in the HUD portrait. Pulls from the resolved
        /// TowerDefinition; falls back to a generic label if the registry hasn't
        /// resolved the def yet on this client.</summary>
        public string DisplayName
        {
            get
            {
                var def = TowerPlacementManager.GetDefinition(towerTypeId.Value);
                return def != null ? def.DisplayName : "Tower (building)";
            }
        }

        public SelectableKind Kind => SelectableKind.BuildSite;

        public Transform SelectionTransform => transform;

        // Match the TowerInstance's radius formula so the selection ring is the
        // same size before vs. after the build completes — no visual pop on transition.
        public float SelectionRadius
        {
            get
            {
                var def = TowerPlacementManager.GetDefinition(towerTypeId.Value);
                Vector2Int fp = def != null ? def.FootprintSize : new Vector2Int(1, 1);
                return Mathf.Max(fp.x, fp.y) * 0.5f * GridCoordinates.TILE_SIZE + 0.5f;
            }
        }

        // ----- Pre-spawn init data (server) -------------------------------

        private PlayerSlot pendingOwner = PlayerSlot.None;
        private float pendingBuildTime;
        private Vector2Int pendingAnchor;
        private int pendingTowerTypeId;
        private int pendingGoldSpent;
        private bool hasPendingInit;

        // Spawned child targeting-reticle effect (local, all peers). Fed progress in Update;
        // destroyed automatically with this NetworkObject at completion/cancel.
        private TowerDropReticle dropReticleInstance;

        // ----- Lifecycle --------------------------------------------------

        /// <summary>
        /// Server-only: stores the data that <see cref="OnNetworkSpawn"/> will write
        /// into NetworkVariables. Must be called between Instantiate and Spawn().
        /// </summary>
        /// <remarks>
        /// Owner identity is conveyed through NGO ownership (via SpawnWithOwnership),
        /// not through this method — see <see cref="NetworkBehaviour.OwnerClientId"/>.
        /// </remarks>
        public void InitializeServer(TowerDefinition def, PlayerSlot owner,
                                     Vector2Int anchorTile, int towerTypeIdValue,
                                     int goldSpentValue)
        {
            var nm = NetworkManager.Singleton;
            if (nm == null || !nm.IsServer)
            {
                Debug.LogError("[BuildSiteVisual] InitializeServer called when not running as server.");
                return;
            }

            pendingOwner = owner;
            pendingBuildTime = def != null ? def.BuildTime : 0f;
            pendingAnchor = anchorTile;
            pendingTowerTypeId = towerTypeIdValue;
            pendingGoldSpent = goldSpentValue;
            hasPendingInit = true;
        }

        public override void OnNetworkSpawn()
        {
            // Auto-populate tinted renderers if not configured in the inspector.
            if (tintedRenderers == null || tintedRenderers.Length == 0)
                tintedRenderers = GetComponentsInChildren<MeshRenderer>();

            // Server: now that the NetworkObject is spawned, write the pending init
            // values into NetworkVariables. NGO captures these into the initial sync
            // message so clients see correct values on their first OnNetworkSpawn.
            if (IsServer && hasPendingInit)
            {
                ownerSlot.Value = pendingOwner;
                buildTime.Value = pendingBuildTime;
                anchor.Value = pendingAnchor;
                towerTypeId.Value = pendingTowerTypeId;
                goldSpent.Value = pendingGoldSpent;
                hasPendingInit = false;
            }

            // Spawn the targeting-reticle FX as a local child. It reads this build site's
            // replicated progress (fed in Update) and dies with us at completion/cancel.
            if (dropReticlePrefab != null)
            {
                dropReticleInstance = Instantiate(dropReticlePrefab, transform);
                dropReticleInstance.transform.localPosition = Vector3.zero;
                dropReticleInstance.transform.localRotation = Quaternion.identity;
            }

            // Subscribe to value changes so visual updates are reactive.
            currentStage.OnValueChanged += HandleStageChanged;

            // Apply initial visual state based on the (now-replicated) values.
            ApplyStageMaterialAndTint(currentStage.Value);
        }

        public override void OnNetworkDespawn()
        {
            currentStage.OnValueChanged -= HandleStageChanged;

            // Server-only cleanup: if this visual was shelved at the time it was
            // despawned (e.g., the player disconnected while a tower was shelved),
            // restore walkability and occupancy on the footprint. Non-shelved
            // visuals are owned by their Builder, which handles cleanup via
            // jobIdToVisual; we mustn't double-free in that case.
            if (IsServer && isShelved.Value)
            {
                RestoreFootprintGridState();
            }

            // Local-only selection hygiene. If this visual was the active selection
            // AND nothing has transferred selection to a replacement (e.g., a
            // TowerInstance that just spawned at the same anchor), clear so HUD/
            // visualizer don't hold a destroyed reference. The completion path
            // spawns TowerInstance BEFORE this despawn arrives on the client; that
            // spawn already transferred selection, so this check passes through.
            if (SelectionState.Instance != null && SelectionState.Instance.IsSelected(this))
                SelectionState.Instance.Clear();
        }

        // Server-only: restore walkability=true and occupancy=false on this build site's
        // footprint. Called when a shelved visual is despawned without going through a
        // normal "resume → cancel" cycle (e.g., player disconnect cleanup).
        private void RestoreFootprintGridState()
        {
            var loader = LevelLoader.Instance;
            if (loader == null || !loader.IsLoaded) return;

            var def = TowerPlacementManager.GetDefinition(towerTypeId.Value);
            if (def == null) return;

            foreach (var tile in GridCoordinates.GetFootprintTiles(
                                     anchor.Value, def.FootprintSize))
            {
                loader.SetOccupied(tile, false);
                loader.SetWalkable(tile, true);
            }
        }

        // ----- Per-frame visual update (all peers) ------------------------

        private void Update()
        {
            // Drive the targeting reticle on every peer, every stage: 0 while Queued
            // (full-size reticle, awaiting a builder), shrinking while Constructing, frozen
            // while Paused. This is the only per-frame visual effect on the build site —
            // nothing about the site's mesh grows or changes shape during construction.
            if (dropReticleInstance != null)
                dropReticleInstance.SetProgress(ComputeProgressNormalized());
        }

        // ----- Server API -------------------------------------------------

        /// <summary>
        /// Server-only: marks this visual as shelved. The visual remains in the world
        /// but no longer belongs to the owning Builder's queue. Stage stays Paused;
        /// this method just flips the IsShelved flag so the visual takes responsibility
        /// for its own grid-state cleanup on despawn.
        /// </summary>
        public void ServerMarkShelved()
        {
            if (!IsServer) return;
            isShelved.Value = true;
        }

        /// <summary>
        /// Server-only: marks this visual as unshelved (taken back into a Builder's queue).
        /// Called when the player right-clicks a shelved visual to resume construction.
        /// Grid-state cleanup is once again the Builder's responsibility via jobIdToVisual.
        /// </summary>
        public void ServerMarkUnshelved()
        {
            if (!IsServer) return;
            isShelved.Value = false;
        }

        // ----- Player-initiated cancel (HUD action) -----------------------

        // Server-only guard against double cancel — Cancel RPC could arrive twice
        // if the player clicks quickly before the visual finishes despawning.
        private bool serverCancelled;

        /// <summary>
        /// Owner-only RPC. Routes to <see cref="ServerCancel"/>. Hooked up to the
        /// Cancel action button in the HUD's action menu.
        /// </summary>
        [Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Owner)]
        public void RequestCancelRpc()
        {
            ServerCancel();
        }

        /// <summary>
        /// Server-only: cancel this build. Two paths depending on shelve state:
        ///   - <b>Shelved</b>: this visual is standalone (not in any builder's queue).
        ///     Refund gold ourselves and despawn — <see cref="OnNetworkDespawn"/>
        ///     restores the footprint's grid state because <c>isShelved</c> is true.
        ///   - <b>In a builder's queue</b>: route through the owning builder's
        ///     <see cref="Builder.ServerCancelJobAtAnchor"/>, which already handles
        ///     refund + grid restore + visual despawn through its job-cleanup path.
        /// </summary>
        public void ServerCancel()
        {
            if (!IsServer) return;
            if (serverCancelled) return;            // idempotent guard
            serverCancelled = true;

            if (isShelved.Value)
            {
                RefundOwner();
                if (NetworkObject.IsSpawned)
                    NetworkObject.Despawn(destroy: true);
                return;
            }

            // Queued / Constructing / Paused — owned by a builder's job queue.
            var builder = Builder.GetForClient(OwnerClientId);
            if (builder != null)
            {
                bool found = builder.ServerCancelJobAtAnchor(anchor.Value);
                if (found) return;
                // Race: visual exists but no matching job (e.g., job just completed
                // and the visual is mid-despawn). Fall through to manual cleanup.
                Debug.LogWarning($"[BuildSiteVisual] ServerCancel: no matching job " +
                                 $"at anchor {anchor.Value} on builder for client " +
                                 $"{OwnerClientId}. Performing manual refund+despawn.");
            }
            else
            {
                Debug.LogWarning("[BuildSiteVisual] ServerCancel: owning builder " +
                                 "not found. Performing manual refund+despawn.");
            }

            // Manual fallback for the race / no-builder cases. Restore grid since
            // the builder isn't going to do it for us.
            RefundOwner();
            if (currentStage.Value == BuildStage.Constructing
                || currentStage.Value == BuildStage.Paused)
            {
                RestoreFootprintGridState();
            }
            if (NetworkObject.IsSpawned)
                NetworkObject.Despawn(destroy: true);
        }

        private void RefundOwner()
        {
            var goldManager = PlayerGoldManager.GetForClient(OwnerClientId);
            if (goldManager == null) return;
            goldManager.AwardGold(goldSpent.Value);
        }

        /// <summary>
        /// Server-only: transitions the visual from Queued (or Paused) to Constructing
        /// and records the server time for stage progression. Caller is responsible
        /// for setting <paramref name="accumulatedTimeBeforeThisRun"/> from the BuildJob's
        /// AccumulatedConstructionTime — non-zero values mean this is a resume.
        /// </summary>
        public void ServerBeginConstructing(float accumulatedTimeBeforeThisRun)
        {
            if (!IsServer) return;
            if (currentStage.Value == BuildStage.Constructing) return;

            accumulatedConstructionTime.Value = accumulatedTimeBeforeThisRun;
            constructionStartServerTime.Value =
                (float)NetworkManager.Singleton.ServerTime.Time;
            currentStage.Value = BuildStage.Constructing;
        }

        /// <summary>
        /// Server-only: transitions Constructing → Paused AND writes the new
        /// accumulated construction time (freezing the reticle's shrink progress at that
        /// point). After this returns, the visual is fully self-describing — it carries
        /// enough state to be shelved and later resumed.
        /// </summary>
        public void ServerPauseAndPersistAccumulated(float totalAccumulated)
        {
            if (!IsServer) return;
            if (currentStage.Value != BuildStage.Constructing) return;

            accumulatedConstructionTime.Value = totalAccumulated;
            // Reset constructionStartServerTime to -1 so any future progress reads
            // know there's no active timer running.
            constructionStartServerTime.Value = -1f;
            currentStage.Value = BuildStage.Paused;
        }

        // ----- Visual state machine ---------------------------------------

        private void HandleStageChanged(BuildStage previous, BuildStage current)
        {
            ApplyStageMaterialAndTint(current);
        }

        // Applies the stage's material + owner tint to the site marker's renderers.
        // Paused falls back to the constructing material if no paused material is assigned.
        private void ApplyStageMaterialAndTint(BuildStage stage)
        {
            switch (stage)
            {
                case BuildStage.Queued:
                    SwapMaterial(queuedMaterial);   // green ghost — no owner tint
                    break;
                case BuildStage.Constructing:
                    SwapMaterial(constructingMaterial);
                    ApplyOwnerTint();
                    break;
                case BuildStage.Paused:
                    SwapMaterial(pausedMaterial != null ? pausedMaterial : constructingMaterial);
                    ApplyOwnerTint();
                    break;
            }
        }

        // ----- Material handling ------------------------------------------

        private void SwapMaterial(Material mat)
        {
            if (mat == null || tintedRenderers == null) return;
            foreach (var rend in tintedRenderers)
            {
                if (rend == null) continue;
                rend.sharedMaterial = mat;
            }
        }

        // Reused per-instance to avoid GC. Lazy because Unity disallows
        // construction in field initializers.
        private MaterialPropertyBlock colorPropertyBlock;
        private static readonly int ColorPropertyId = Shader.PropertyToID("_Color");
        private static readonly int BaseColorPropertyId = Shader.PropertyToID("_BaseColor");

        private void ApplyOwnerTint()
        {
            if (tintedRenderers == null) return;

            Color c = PlayerColors.Get(ownerSlot.Value);
            c.a = 1f;

            colorPropertyBlock ??= new MaterialPropertyBlock();
            colorPropertyBlock.SetColor(ColorPropertyId, c);
            colorPropertyBlock.SetColor(BaseColorPropertyId, c);

            foreach (var rend in tintedRenderers)
            {
                if (rend == null) continue;
                rend.SetPropertyBlock(colorPropertyBlock);
            }
        }
    }
}