using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Sockets;
using FloodSWE.IO;
using FloodSWE.Streaming;
using FloodSWE.TileGraph;
using UnityEngine;

namespace FloodSWE.Networking
{
    public sealed class SweServerRuntime : MonoBehaviour
    {
        [Header("Simulation")]
        public SweTileSimulator simulator;
        public SweTileLoader tileLoader;
        public string activeLod = "lod1";
        public int activeTileX = 1;
        public int activeTileY = 1;
        public bool applyTileOnStart = true;

        [Header("Boundary Manifest")]
        public TextAsset boundaryManifestAsset;
        public string boundaryManifestPath = "GeoData/export_swe/swe_boundaries.json";

        [Header("Network")]
        public int commandListenPort = 29010;
        public string questHost = "";
        public int questFramePort = 29011;
        public bool acceptFirstCommandSenderAsQuest = true;

        [Header("Frame Stream")]
        public float targetFrameHz = 10.0f;
        [Tooltip("Maximum UDP payload bytes for a single frame datagram.")]
        public int maxFramePayloadBytes = 60000;
        [Tooltip("If enabled, oversized frames are downsampled until they fit max payload size.")]
        public bool downsampleOversizedFrames = true;
        [Tooltip("Lowest allowed resolution when downsampling oversized frames.")]
        public int minFrameResolution = 64;

        [Header("Source/Sink Control")]
        public float sourceDepthRatePerLevelMps = 0.01f;
        public float sinkDepthRatePerLevelMps = 0.01f;
        [Tooltip("Applied to free_outflow sinks when no explicit sink level is set.")]
        public float freeOutflowBaseLevel = 1.0f;
        public bool applyFreeOutflowByDefault = true;
        [Tooltip("Applies an initial source level on startup for quick validation without client commands.")]
        public bool applyDefaultSourceOnStart = false;
        public int defaultSourceId = 1;
        public float defaultSourceLevel = 1.0f;
        public bool verboseDiagnostics = true;
        public float simThroughputAveragingSeconds = 1.0f;
        [Range(0.0f, 1.0f)]
        public float simThroughputSmoothing = 0.35f;
        public float clientSignalTimeoutSeconds = 3.0f;

        private readonly Dictionary<int, float> sourceLevels = new Dictionary<int, float>();
        private readonly Dictionary<int, float> sinkLevels = new Dictionary<int, float>();
        private readonly Dictionary<string, SweCheckpointState> checkpoints = new Dictionary<string, SweCheckpointState>(StringComparer.OrdinalIgnoreCase);

        private SweBoundaryManifest boundaryManifest;
        private HashSet<int> activeSourceIds = new HashSet<int>();
        private HashSet<int> activeSinkIds = new HashSet<int>();

        private UdpClient commandSocket;
        private IPEndPoint commandEndpoint;
        private IPEndPoint questEndpoint;
        private readonly Dictionary<string, IPEndPoint> frameSubscribers = new Dictionary<string, IPEndPoint>(StringComparer.Ordinal);
        private int lastOversizeWarningFrameId = -1;
        private string lastMissingMaskWarningTileKey = "";
        private int receivedControlPackets;
        private int decodedControlPackets;
        private int invalidControlPackets;
        private int ackPacketsSent;
        private int droppedFramePackets;
        private int transmittedFramePackets;
        private long transmittedFrameBytes;
        private int lastFramePayloadBytes;
        private string lastCommandName = "none";
        private string lastCommandSender = "n/a";
        private float lastCommandTimeUnscaled = -1.0f;
        private float lastClientChangeTimeUnscaled = -1.0f;
        private float simulatedSecondsPerSecond;
        private int lastPacketFrameId = -1;
        private float lastPacketTimeUnscaled = -1.0f;
        private float throughputWindowRealSeconds;
        private float throughputWindowSimSeconds;
        private int lastForcedCellCount;
        private string lastForcingStatus = "idle";

        public string ActiveTileLabel => $"{activeLod} ({activeTileX},{activeTileY})";
        public int ConnectedClientCount => frameSubscribers.Count;
        public bool HasConnectedClients => frameSubscribers.Count > 0;
        public string QuestEndpointLabel => questEndpoint != null ? questEndpoint.ToString() : "none";
        public float SimulatedSecondsPerSecond => simulatedSecondsPerSecond;
        public bool HasSimulationThroughput => simulatedSecondsPerSecond > 0.0f;
        public string LastCommandName => lastCommandName;
        public string LastCommandSender => lastCommandSender;
        public float LastCommandAgeSeconds => lastCommandTimeUnscaled >= 0.0f ? Time.unscaledTime - lastCommandTimeUnscaled : float.PositiveInfinity;
        public bool HasRecentClientSignal => lastCommandTimeUnscaled >= 0.0f && LastCommandAgeSeconds <= Mathf.Max(0.1f, clientSignalTimeoutSeconds);
        public int ReceivedControlPackets => receivedControlPackets;
        public int DecodedControlPackets => decodedControlPackets;
        public int InvalidControlPackets => invalidControlPackets;
        public int AckPacketsSent => ackPacketsSent;
        public int DroppedFramePackets => droppedFramePackets;
        public int TransmittedFramePackets => transmittedFramePackets;
        public long TransmittedFrameBytes => transmittedFrameBytes;
        public int LastFramePayloadBytes => lastFramePayloadBytes;
        public string LastForcingStatus => lastForcingStatus;
        public int LastForcedCellCount => lastForcedCellCount;
        public string TileLoadSummary => tileLoader != null ? tileLoader.LastLoadSummary : "SweTileLoader missing";
        public float LastClientChangeAgeSeconds => lastClientChangeTimeUnscaled >= 0.0f ? Time.unscaledTime - lastClientChangeTimeUnscaled : float.PositiveInfinity;
        public string DiagnosticsSummary => BuildDiagnosticsSummary();

        private void OnEnable()
        {
            ResetDiagnostics();
            if (simulator == null)
            {
                simulator = GetComponent<SweTileSimulator>();
            }

            if (simulator == null)
            {
                Debug.LogError("SweServerRuntime: missing SweTileSimulator reference.");
                enabled = false;
                return;
            }

            if (applyTileOnStart)
            {
                bool loaded = TrySetActiveTile(activeLod, activeTileX, activeTileY);
                if (!loaded)
                {
                    Debug.LogWarning($"SweServerRuntime: failed to load tile {activeLod} ({activeTileX},{activeTileY}).");
                }
            }
            simulator.emitHeightmapPackets = true;
            simulator.packetEveryNTicks = ComputePacketInterval(simulator.tickSeconds, targetFrameHz);
            simulator.HeightmapPacketReady += OnHeightmapPacket;

            LoadBoundaryManifest();
            RefreshActiveTileBoundaryIds();
            ApplyDefaultSourceIfConfigured();
            RecomputeExternalDepthRate();

            StartNetworking();
        }

        private void OnDisable()
        {
            if (simulator != null)
            {
                simulator.HeightmapPacketReady -= OnHeightmapPacket;
            }

            StopNetworking();
        }

        private void Update()
        {
            PollCommands();
            UpdateThroughputSmoothing();
        }

        private void OnHeightmapPacket(HeightmapPacket packet)
        {
            TrackSimulationProgress(packet);
            if (frameSubscribers.Count == 0)
            {
                return;
            }

            if (!TryBuildTransmitPayload(packet, out HeightmapPacket transmitPacket, out byte[] payload))
            {
                return;
            }

            var stale = new List<string>();
            foreach (var kv in frameSubscribers)
            {
                try
                {
                    commandSocket.Send(payload, payload.Length, kv.Value);
                    transmittedFramePackets++;
                    transmittedFrameBytes += payload.Length;
                    lastFramePayloadBytes = payload.Length;
                }
                catch (Exception ex)
                {
                    stale.Add(kv.Key);
                    Debug.LogWarning($"SweServerRuntime: failed to send frame to {kv.Value}. {ex.Message}");
                }
            }

            for (int i = 0; i < stale.Count; i++)
            {
                if (frameSubscribers.Remove(stale[i]))
                {
                    lastClientChangeTimeUnscaled = Time.unscaledTime;
                }
            }
        }

        private bool TryBuildTransmitPayload(HeightmapPacket originalPacket, out HeightmapPacket transmitPacket, out byte[] payload)
        {
            transmitPacket = originalPacket;
            payload = SweUdpProtocol.EncodeFrame(transmitPacket);
            int maxBytes = Mathf.Clamp(maxFramePayloadBytes, 1200, 65507);
            if (payload.Length <= maxBytes)
            {
                return true;
            }

            if (!downsampleOversizedFrames)
            {
                WarnOversizedFrame(originalPacket.FrameId, originalPacket.Resolution, originalPacket.Resolution, payload.Length, maxBytes);
                droppedFramePackets++;
                return false;
            }

            if (!originalPacket.TryDecodeHeights(out float[] sourceHeights))
            {
                if (lastOversizeWarningFrameId != originalPacket.FrameId)
                {
                    lastOversizeWarningFrameId = originalPacket.FrameId;
                    Debug.LogWarning($"SweServerRuntime: oversized frame {originalPacket.FrameId} ({payload.Length} bytes) and decode failed.");
                }
                droppedFramePackets++;
                return false;
            }

            int sourceRes = originalPacket.Resolution;
            int targetRes = sourceRes;
            int minRes = Mathf.Max(8, minFrameResolution);

            while (payload.Length > maxBytes && targetRes > minRes)
            {
                targetRes = Mathf.Max(minRes, targetRes / 2);
                float[] downsampled = DownsampleHeightsNearest(sourceHeights, sourceRes, targetRes);
                transmitPacket = HeightmapPacket.FromHeights(originalPacket.FrameId, originalPacket.Tile, targetRes, downsampled);
                payload = SweUdpProtocol.EncodeFrame(transmitPacket);
            }

            if (payload.Length <= maxBytes)
            {
                return true;
            }

            WarnOversizedFrame(originalPacket.FrameId, sourceRes, targetRes, payload.Length, maxBytes);
            droppedFramePackets++;
            return false;
        }

        private float[] DownsampleHeightsNearest(float[] source, int sourceRes, int targetRes)
        {
            float[] result = new float[targetRes * targetRes];
            float denom = Mathf.Max(1.0f, targetRes - 1.0f);
            float sourceMax = sourceRes - 1.0f;
            int idx = 0;
            for (int y = 0; y < targetRes; y++)
            {
                int sy = Mathf.Clamp(Mathf.RoundToInt((y / denom) * sourceMax), 0, sourceRes - 1);
                int sourceRow = sy * sourceRes;
                for (int x = 0; x < targetRes; x++)
                {
                    int sx = Mathf.Clamp(Mathf.RoundToInt((x / denom) * sourceMax), 0, sourceRes - 1);
                    result[idx++] = source[sourceRow + sx];
                }
            }

            return result;
        }

        private void WarnOversizedFrame(int frameId, int sourceRes, int finalRes, int payloadBytes, int maxBytes)
        {
            if (lastOversizeWarningFrameId == frameId)
            {
                return;
            }

            lastOversizeWarningFrameId = frameId;
            Debug.LogWarning(
                $"SweServerRuntime: dropped frame {frameId}; payload {payloadBytes}B exceeds max {maxBytes}B " +
                $"(sourceRes={sourceRes}, finalRes={finalRes}).");
        }

        private void StartNetworking()
        {
            try
            {
                commandSocket = new UdpClient(commandListenPort);
                commandSocket.Client.Blocking = false;
                commandEndpoint = new IPEndPoint(IPAddress.Any, 0);
            }
            catch (Exception ex)
            {
                Debug.LogError($"SweServerRuntime: failed to start command socket on port {commandListenPort}. {ex.Message}");
                enabled = false;
                return;
            }

            if (!string.IsNullOrWhiteSpace(questHost))
            {
                try
                {
                    IPAddress[] addresses = Dns.GetHostAddresses(questHost.Trim());
                    if (addresses.Length > 0)
                    {
                        questEndpoint = new IPEndPoint(addresses[0], questFramePort);
                        AddFrameSubscriber(questEndpoint);
                        Debug.Log($"SweServerRuntime: fixed Quest endpoint {questEndpoint}.");
                    }
                }
                catch (Exception ex)
                {
                    Debug.LogWarning($"SweServerRuntime: could not resolve quest host '{questHost}'. {ex.Message}");
                }
            }
        }

        private void StopNetworking()
        {
            if (commandSocket != null)
            {
                commandSocket.Close();
                commandSocket = null;
            }

            commandEndpoint = null;
            questEndpoint = null;
            if (frameSubscribers.Count > 0)
            {
                lastClientChangeTimeUnscaled = Time.unscaledTime;
            }
            frameSubscribers.Clear();
        }

        private void PollCommands()
        {
            if (commandSocket == null)
            {
                return;
            }

            while (commandSocket.Available > 0)
            {
                byte[] raw;
                IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
                try
                {
                    raw = commandSocket.Receive(ref sender);
                }
                catch (SocketException)
                {
                    break;
                }

                if (raw == null || raw.Length == 0)
                {
                    continue;
                }
                receivedControlPackets++;

                if (acceptFirstCommandSenderAsQuest && questEndpoint == null)
                {
                    questEndpoint = new IPEndPoint(sender.Address, questFramePort);
                    AddFrameSubscriber(questEndpoint);
                    Debug.Log($"SweServerRuntime: learned Quest endpoint {questEndpoint} from command sender {sender}.");
                }

                if (!SweUdpProtocol.TryDecodeControl(raw, out SweControlCommand command) || command == null)
                {
                    invalidControlPackets++;
                    continue;
                }

                decodedControlPackets++;
                lastCommandName = string.IsNullOrWhiteSpace(command.command) ? "unknown" : command.command.Trim();
                lastCommandSender = sender.ToString();
                lastCommandTimeUnscaled = Time.unscaledTime;
                HandleCommand(command, sender);
            }
        }

        private void HandleCommand(SweControlCommand command, IPEndPoint sender)
        {
            string cmd = command.command != null ? command.command.Trim().ToLowerInvariant() : string.Empty;
            switch (cmd)
            {
                case "set_source_level":
                    sourceLevels[command.sourceId] = command.sourceLevel;
                    RecomputeExternalDepthRate();
                    SendAck(sender, $"source {command.sourceId} level={command.sourceLevel:F3}");
                    break;

                case "set_sink_level":
                    sinkLevels[command.sinkId] = command.sinkLevel;
                    RecomputeExternalDepthRate();
                    SendAck(sender, $"sink {command.sinkId} level={command.sinkLevel:F3}");
                    break;

                case "set_active_tile":
                    if (TrySetActiveTile(command.lod, command.tileX, command.tileY))
                    {
                        SendAck(sender, $"active tile: {activeLod} ({activeTileX},{activeTileY})");
                    }
                    else
                    {
                        SendAck(sender, $"active tile missing: {command.lod} ({command.tileX},{command.tileY})");
                    }
                    break;

                case "save_checkpoint":
                    SaveCheckpoint(command.checkpoint);
                    SendAck(sender, $"checkpoint saved: {command.checkpoint}");
                    break;

                case "reset_checkpoint":
                    bool restored = RestoreCheckpoint(command.checkpoint);
                    SendAck(sender, restored ? $"checkpoint restored: {command.checkpoint}" : $"checkpoint missing: {command.checkpoint}");
                    break;

                case "apply_porosity_stamp":
                    bool stamped = simulator.ApplyPorosityStampNormalized(new Vector2(command.u, command.v), command.radius, command.porosity);
                    SendAck(sender, stamped ? "porosity stamp applied" : "porosity stamp failed");
                    break;

                case "hello":
                    if (acceptFirstCommandSenderAsQuest)
                    {
                        var updated = new IPEndPoint(sender.Address, questFramePort);
                        if (questEndpoint == null || !questEndpoint.Equals(updated))
                        {
                            questEndpoint = updated;
                            Debug.Log($"SweServerRuntime: refreshed Quest endpoint to {questEndpoint} from hello.");
                        }

                        AddFrameSubscriber(updated);
                    }
                    SendAck(sender, "hello");
                    break;

                case "disconnect":
                    RemoveFrameSubscriber(sender.Address, questFramePort);
                    SendAck(sender, "disconnected");
                    break;

                default:
                    SendAck(sender, $"unknown command: {command.command}");
                    break;
            }
        }

        private bool TrySetActiveTile(string lod, int tileX, int tileY)
        {
            string targetLod = string.IsNullOrWhiteSpace(lod) ? activeLod : lod.Trim();
            int targetX = tileX;
            int targetY = tileY;

            if (tileLoader == null)
            {
                activeLod = targetLod;
                activeTileX = targetX;
                activeTileY = targetY;
                simulator.packetTileId = new TileId(SweBoundaryManifest.ParseLod(activeLod), activeTileX, activeTileY);
                RefreshActiveTileBoundaryIds();
                RecomputeExternalDepthRate();
                return true;
            }

            bool loaded = tileLoader.ApplyToSimulator(targetLod, targetX, targetY, simulator);
            if (!loaded)
            {
                if (verboseDiagnostics && tileLoader != null)
                {
                    Debug.LogWarning($"SweServerRuntime: tile load diagnostics => {tileLoader.LastLoadSummary}");
                }
                return false;
            }

            activeLod = targetLod;
            activeTileX = targetX;
            activeTileY = targetY;
            simulator.packetTileId = new TileId(SweBoundaryManifest.ParseLod(activeLod), activeTileX, activeTileY);
            RefreshActiveTileBoundaryIds();
            RecomputeExternalDepthRate();
            if (verboseDiagnostics && tileLoader != null)
            {
                Debug.Log($"SweServerRuntime: active tile set => {tileLoader.LastLoadSummary}");
            }
            return true;
        }

        private void SendAck(IPEndPoint target, string message)
        {
            if (commandSocket == null || target == null)
            {
                return;
            }

            byte[] payload = SweUdpProtocol.EncodeAck(message);
            try
            {
                commandSocket.Send(payload, payload.Length, target);
                ackPacketsSent++;
            }
            catch (Exception ex)
            {
                Debug.LogWarning($"SweServerRuntime: failed to send ack. {ex.Message}");
            }
        }

        private void LoadBoundaryManifest()
        {
            string json = null;
            if (boundaryManifestAsset != null)
            {
                json = boundaryManifestAsset.text;
            }
            else if (!string.IsNullOrWhiteSpace(boundaryManifestPath))
            {
                string path = boundaryManifestPath;
                if (!Path.IsPathRooted(path))
                {
                    path = Path.Combine(Directory.GetCurrentDirectory(), boundaryManifestPath);
                }

                if (File.Exists(path))
                {
                    json = File.ReadAllText(path);
                }
            }

            if (!SweBoundaryManifest.TryLoad(json, out boundaryManifest))
            {
                Debug.LogWarning("SweServerRuntime: boundary manifest missing or invalid. Source/sink control disabled for this run.");
                boundaryManifest = null;
                lastForcingStatus = "disabled:manifest_missing_or_invalid";
            }
        }

        private void RefreshActiveTileBoundaryIds()
        {
            activeSourceIds = new HashSet<int>();
            activeSinkIds = new HashSet<int>();

            if (boundaryManifest == null)
            {
                lastForcingStatus = "disabled:no_manifest";
                return;
            }

            if (!boundaryManifest.TryGetTile(activeLod, activeTileX, activeTileY, out SweBoundaryTile tile) || tile == null)
            {
                Debug.LogWarning($"SweServerRuntime: no boundary entry for tile {activeLod} ({activeTileX},{activeTileY}).");
                lastForcingStatus = "disabled:no_tile_boundary_entry";
                return;
            }

            if (tile.source_ids != null)
            {
                for (int i = 0; i < tile.source_ids.Length; i++)
                {
                    SweBoundaryTileIdRef entry = tile.source_ids[i];
                    if (entry != null && entry.id > 0)
                    {
                        activeSourceIds.Add(entry.id);
                    }
                }
            }

            if (tile.sink_ids != null)
            {
                for (int i = 0; i < tile.sink_ids.Length; i++)
                {
                    SweBoundaryTileIdRef entry = tile.sink_ids[i];
                    if (entry != null && entry.id > 0)
                    {
                        activeSinkIds.Add(entry.id);
                    }
                }
            }

            Debug.Log($"SweServerRuntime: active tile sources={activeSourceIds.Count}, sinks={activeSinkIds.Count}");
        }

        private void RecomputeExternalDepthRate()
        {
            var sourceRates = new Dictionary<int, float>();
            foreach (int sourceId in activeSourceIds)
            {
                if (!sourceLevels.TryGetValue(sourceId, out float value))
                {
                    continue;
                }

                float rate = Mathf.Max(0.0f, value) * sourceDepthRatePerLevelMps;
                if (rate > 0.0f)
                {
                    sourceRates[sourceId] = rate;
                }
            }

            var sinkRates = new Dictionary<int, float>();
            foreach (int sinkId in activeSinkIds)
            {
                if (sinkLevels.TryGetValue(sinkId, out float value))
                {
                    float rate = Mathf.Max(0.0f, value) * sinkDepthRatePerLevelMps;
                    if (rate > 0.0f)
                    {
                        sinkRates[sinkId] = rate;
                    }
                    continue;
                }

                if (applyFreeOutflowByDefault &&
                    boundaryManifest != null &&
                    boundaryManifest.TryGetSink(sinkId, out SweBoundarySink sink) &&
                    sink != null &&
                    sink.@params != null &&
                    sink.@params.IsMode("free_outflow"))
                {
                    float rate = Mathf.Max(0.0f, freeOutflowBaseLevel) * sinkDepthRatePerLevelMps;
                    if (rate > 0.0f)
                    {
                        sinkRates[sinkId] = rate;
                    }
                }
            }

            bool hasBoundaryRates = sourceRates.Count > 0 || sinkRates.Count > 0;
            if (!hasBoundaryRates)
            {
                lastForcedCellCount = 0;
                lastForcingStatus = "disabled:no_active_source_or_sink_levels";
                simulator.ClearExternalDepthRateMap();
                simulator.SetExternalDepthRate(0.0f);
                return;
            }

            if (simulator.TryGetBoundaryIdMasks(out int[] sourceMask, out int[] sinkMask))
            {
                int n = simulator.gridRes * simulator.gridRes;
                float[] perCell = new float[n];
                bool anyNonZero = false;
                int forcedCellCount = 0;

                for (int i = 0; i < n; i++)
                {
                    if (!IsBorderCell(i, simulator.gridRes))
                    {
                        perCell[i] = 0.0f;
                        continue;
                    }

                    float rate = 0.0f;
                    if (sourceMask != null)
                    {
                        int sourceId = sourceMask[i];
                        if (sourceId > 0 && sourceRates.TryGetValue(sourceId, out float sourceRate))
                        {
                            rate += sourceRate;
                        }
                    }

                    if (sinkMask != null)
                    {
                        int sinkId = sinkMask[i];
                        if (sinkId > 0 && sinkRates.TryGetValue(sinkId, out float sinkRate))
                        {
                            rate -= sinkRate;
                        }
                    }

                    perCell[i] = rate;
                    anyNonZero = anyNonZero || Mathf.Abs(rate) > 1e-9f;
                    if (Mathf.Abs(rate) > 1e-9f)
                    {
                        forcedCellCount++;
                    }
                }

                if (anyNonZero && simulator.SetExternalDepthRateMap(perCell))
                {
                    simulator.SetExternalDepthRate(0.0f);
                    lastForcedCellCount = forcedCellCount;
                    lastForcingStatus = "localized";
                    Debug.Log($"SweServerRuntime: applied localized boundary forcing cells={forcedCellCount}");
                    return;
                }

                lastForcedCellCount = 0;
                lastForcingStatus = "disabled:boundary_masks_zero_or_apply_failed";
            }
            else
            {
                string key = $"{activeLod}|{activeTileX}|{activeTileY}";
                if (!string.Equals(lastMissingMaskWarningTileKey, key, StringComparison.Ordinal))
                {
                    lastMissingMaskWarningTileKey = key;
                    Debug.LogWarning(
                        $"SweServerRuntime: no readable source/sink ID masks for tile {activeLod} ({activeTileX},{activeTileY}); " +
                        "disabling source/sink forcing.");
                }

                lastForcedCellCount = 0;
                lastForcingStatus = "disabled:masks_unavailable";
            }

            // Strict mode: no masks means no forcing. This prevents non-physical uniform flooding.
            simulator.ClearExternalDepthRateMap();
            simulator.SetExternalDepthRate(0.0f);
        }

        private static bool IsBorderCell(int flatIndex, int resolution)
        {
            if (resolution <= 1)
            {
                return true;
            }

            int x = flatIndex % resolution;
            int y = flatIndex / resolution;
            return x == 0 || y == 0 || x == resolution - 1 || y == resolution - 1;
        }

        private void ApplyDefaultSourceIfConfigured()
        {
            if (!applyDefaultSourceOnStart)
            {
                return;
            }

            if (defaultSourceId <= 0)
            {
                Debug.LogWarning("SweServerRuntime: default source is enabled, but defaultSourceId is <= 0.");
                return;
            }

            if (!activeSourceIds.Contains(defaultSourceId))
            {
                Debug.LogWarning(
                    $"SweServerRuntime: default source id {defaultSourceId} is not active on tile {activeLod} ({activeTileX},{activeTileY}).");
                return;
            }

            float clamped = Mathf.Max(0.0f, defaultSourceLevel);
            sourceLevels[defaultSourceId] = clamped;
            Debug.Log($"SweServerRuntime: applied startup source id={defaultSourceId} level={clamped:0.###}");
        }

        private void SaveCheckpoint(string checkpointName)
        {
            if (string.IsNullOrWhiteSpace(checkpointName))
            {
                checkpointName = "default";
            }

            if (!simulator.TryCaptureWaterHeights(out float[] water))
            {
                Debug.LogWarning("SweServerRuntime: checkpoint capture failed (water).");
                return;
            }

            simulator.TryCapturePorosity(out float[] porosity);

            SweCheckpointState state = new SweCheckpointState
            {
                waterHeights = water,
                porosityValues = porosity,
                sourceLevels = CloneDictionary(sourceLevels),
                sinkLevels = CloneDictionary(sinkLevels),
            };

            checkpoints[checkpointName] = state;
        }

        private bool RestoreCheckpoint(string checkpointName)
        {
            if (string.IsNullOrWhiteSpace(checkpointName))
            {
                checkpointName = "default";
            }

            if (!checkpoints.TryGetValue(checkpointName, out SweCheckpointState state) || state == null)
            {
                return false;
            }

            bool restoredWater = simulator.TryRestoreWaterHeights(state.waterHeights, true);
            if (!restoredWater)
            {
                return false;
            }

            if (state.porosityValues != null)
            {
                simulator.TryRestorePorosity(state.porosityValues);
            }

            sourceLevels.Clear();
            sinkLevels.Clear();

            if (state.sourceLevels != null)
            {
                foreach (var pair in state.sourceLevels)
                {
                    sourceLevels[pair.Key] = pair.Value;
                }
            }

            if (state.sinkLevels != null)
            {
                foreach (var pair in state.sinkLevels)
                {
                    sinkLevels[pair.Key] = pair.Value;
                }
            }

            RecomputeExternalDepthRate();
            return true;
        }

        private static Dictionary<int, float> CloneDictionary(Dictionary<int, float> source)
        {
            var clone = new Dictionary<int, float>();
            if (source == null)
            {
                return clone;
            }

            foreach (var pair in source)
            {
                clone[pair.Key] = pair.Value;
            }

            return clone;
        }

        private static int ComputePacketInterval(float tickSeconds, float hz)
        {
            if (hz <= 0.0f || tickSeconds <= 0.0f)
            {
                return 1;
            }

            float targetSeconds = 1.0f / hz;
            return Mathf.Max(1, Mathf.RoundToInt(targetSeconds / tickSeconds));
        }

        private void AddFrameSubscriber(IPEndPoint endpoint)
        {
            if (endpoint == null)
            {
                return;
            }

            frameSubscribers[MakeSubscriberKey(endpoint)] = endpoint;
            lastClientChangeTimeUnscaled = Time.unscaledTime;
        }

        private void RemoveFrameSubscriber(IPAddress address, int port)
        {
            if (address == null)
            {
                return;
            }

            string key = MakeSubscriberKey(address, port);
            if (frameSubscribers.Remove(key))
            {
                lastClientChangeTimeUnscaled = Time.unscaledTime;
            }
            if (questEndpoint != null &&
                questEndpoint.Address.Equals(address) &&
                questEndpoint.Port == port)
            {
                questEndpoint = null;
            }
        }

        private static string MakeSubscriberKey(IPEndPoint endpoint)
        {
            return MakeSubscriberKey(endpoint.Address, endpoint.Port);
        }

        private static string MakeSubscriberKey(IPAddress address, int port)
        {
            return $"{address}:{port}";
        }

        private void TrackSimulationProgress(HeightmapPacket packet)
        {
            if (simulator == null || packet == null)
            {
                return;
            }

            float now = Time.unscaledTime;
            if (lastPacketFrameId < 0 || lastPacketTimeUnscaled < 0.0f)
            {
                lastPacketFrameId = packet.FrameId;
                lastPacketTimeUnscaled = now;
                return;
            }

            int frameDelta = packet.FrameId - lastPacketFrameId;
            if (frameDelta <= 0)
            {
                lastPacketFrameId = packet.FrameId;
                lastPacketTimeUnscaled = now;
                return;
            }

            float realDelta = Mathf.Max(0.0001f, now - lastPacketTimeUnscaled);
            float simDelta = frameDelta * Mathf.Max(0.0001f, simulator.tickSeconds);
            throughputWindowRealSeconds += realDelta;
            throughputWindowSimSeconds += simDelta;
            lastPacketFrameId = packet.FrameId;
            lastPacketTimeUnscaled = now;

            float minWindow = Mathf.Max(0.1f, simThroughputAveragingSeconds);
            if (throughputWindowRealSeconds < minWindow)
            {
                return;
            }

            float raw = throughputWindowSimSeconds / Mathf.Max(0.0001f, throughputWindowRealSeconds);
            float blend = Mathf.Clamp01(simThroughputSmoothing);
            if (simulatedSecondsPerSecond <= 0.0f)
            {
                simulatedSecondsPerSecond = raw;
            }
            else
            {
                simulatedSecondsPerSecond = Mathf.Lerp(simulatedSecondsPerSecond, raw, blend);
            }

            throughputWindowRealSeconds = 0.0f;
            throughputWindowSimSeconds = 0.0f;
        }

        private void UpdateThroughputSmoothing()
        {
            if (simulatedSecondsPerSecond <= 0.0f || lastPacketTimeUnscaled < 0.0f)
            {
                return;
            }

            float idleAge = Time.unscaledTime - lastPacketTimeUnscaled;
            if (idleAge <= Mathf.Max(0.1f, simThroughputAveragingSeconds) * 2.0f)
            {
                return;
            }

            simulatedSecondsPerSecond = Mathf.MoveTowards(simulatedSecondsPerSecond, 0.0f, Time.unscaledDeltaTime * 2.0f);
            if (simulatedSecondsPerSecond < 0.001f)
            {
                simulatedSecondsPerSecond = 0.0f;
            }
        }

        private string BuildDiagnosticsSummary()
        {
            return
                $"tile={ActiveTileLabel}; clients={ConnectedClientCount}; recentSignal={HasRecentClientSignal}; " +
                $"simSecPerSec={simulatedSecondsPerSecond:0.00}; forcing={lastForcingStatus}; forcedCells={lastForcedCellCount}; " +
                $"cmd={lastCommandName}@{lastCommandSender}; ctl={decodedControlPackets}/{receivedControlPackets} ack={ackPacketsSent}; " +
                $"frames={transmittedFramePackets} dropped={droppedFramePackets} bytes={transmittedFrameBytes}; " +
                $"loader={TileLoadSummary}";
        }

        private void ResetDiagnostics()
        {
            receivedControlPackets = 0;
            decodedControlPackets = 0;
            invalidControlPackets = 0;
            ackPacketsSent = 0;
            droppedFramePackets = 0;
            transmittedFramePackets = 0;
            transmittedFrameBytes = 0;
            lastFramePayloadBytes = 0;
            lastCommandName = "none";
            lastCommandSender = "n/a";
            lastCommandTimeUnscaled = -1.0f;
            lastClientChangeTimeUnscaled = -1.0f;
            simulatedSecondsPerSecond = 0.0f;
            lastPacketFrameId = -1;
            lastPacketTimeUnscaled = -1.0f;
            throughputWindowRealSeconds = 0.0f;
            throughputWindowSimSeconds = 0.0f;
            lastForcedCellCount = 0;
            lastForcingStatus = "idle";
        }

        [Serializable]
        private sealed class SweCheckpointState
        {
            public float[] waterHeights;
            public float[] porosityValues;
            public Dictionary<int, float> sourceLevels;
            public Dictionary<int, float> sinkLevels;
        }
    }
}