using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using UnityEditor;
using UnityEditor.SceneManagement;
using UnityEngine;
using TD.Core;

namespace TD.Levels.Editor
{
    /// <summary>
    /// Editor-only bake pipeline that runs the seven-phase algorithm against a
    /// <see cref="LevelAuthoring"/> in the active scene and writes the result into the
    /// <see cref="LevelData"/> ScriptableObject pointed to by <c>authoring.targetAsset</c>.
    /// </summary>
    /// <remarks>
    /// Phases:
    ///   1. Volume Discovery (scoped + orphan scan, canonical sort)
    ///   2. Pre-Validation (cheap checks, all errors collected before aborting)
    ///   3. Tile Rasterization (per-volume tile sets, per-zone unions, per-goal sets)
    ///   4. Grid Composition (PlacementGrid + WalkabilityGrid; "Invalid wins")
    ///   5. Spatial Validation (overlap, adjacency, connectivity)
    ///   6. Output Assembly (in-memory LevelData; thumbnail; hash; flat grids; nested data)
    ///   7. Commit (field-by-field copy onto target asset, save, refresh)
    ///
    /// Failed bakes (any hard error in any phase) do NOT modify the existing target asset on
    /// disk. Failure state lives only in <see cref="LevelAuthoringEditorState"/>'s transient
    /// flag, not on the asset itself.
    /// </remarks>
    public static class LevelBakePipeline
    {
        // -------------------------------------------------------------------
        // Public entry point
        // -------------------------------------------------------------------

        /// <summary>
        /// Runs the bake. Returns true on success (with or without warnings); false on hard error.
        /// On failure, <paramref name="authoring"/>.targetAsset is left untouched on disk.
        /// </summary>
        public static bool Bake(LevelAuthoring authoring)
        {
            var report = new BakeReport();

            if (authoring == null)
            {
                Debug.LogError("[LevelBake] Cannot bake: LevelAuthoring is null.");
                return false;
            }

            // -- Phase 1: Volume Discovery -------------------------------
            var ctx = new BakeContext { Authoring = authoring };
            Phase1_Discover(ctx, report);
            if (report.HasErrors) return Abort(report);

            // -- Phase 2: Pre-Validation ---------------------------------
            Phase2_PreValidate(ctx, report);
            if (report.HasErrors) return Abort(report);

            // -- Phase 3: Tile Rasterization -----------------------------
            Phase3_Rasterize(ctx, report);
            if (report.HasErrors) return Abort(report);

            // -- Phase 4: Grid Composition -------------------------------
            Phase4_ComposeGrids(ctx, report);
            if (report.HasErrors) return Abort(report);

            // -- Phase 5: Spatial Validation -----------------------------
            Phase5_SpatialValidate(ctx, report);
            if (report.HasErrors) return Abort(report);

            // -- Phase 6: Output Assembly --------------------------------
            Phase6_AssembleOutput(ctx, report);
            if (report.HasErrors) return Abort(report);

            // -- Phase 7: Commit -----------------------------------------
            Phase7_Commit(ctx, report);
            if (report.HasErrors) return Abort(report);

            // Success path: log warnings (if any) and a summary.
            LevelAuthoringEditorState.HasUncommittedFailure = false;

            BakeOutcome outcome = report.WarningCount > 0
                ? BakeOutcome.SuccessWithWarnings
                : BakeOutcome.Success;

            Debug.Log($"[LevelBake] {outcome} — '{ctx.Authoring.mapName}' " +
                      $"({ctx.PlayerZoneVolumes.Count} player zones, {ctx.SpawnerVolumes.Count} spawners, " +
                      $"{ctx.LeakExitVolumes.Count} leak exits, {ctx.GoalVolumes.Count} goals, " +
                      $"{ctx.MapAreaVolumes.Count} map areas; " +
                      $"grid {ctx.GridSize.x}×{ctx.GridSize.y}; {report.WarningCount} warnings)");

            if (report.WarningCount > 0)
            {
                Debug.LogWarning($"[LevelBake] Bake produced {report.WarningCount} warning(s):\n{report.Format()}");
            }

            return true;
        }

        // Helper: log full report as error and set the transient failure flag.
        private static bool Abort(BakeReport report)
        {
            LevelAuthoringEditorState.HasUncommittedFailure = true;
            Debug.LogError($"[LevelBake] FAILED. Existing target asset (if any) was not modified.\n{report.Format()}");
            return false;
        }

        // -------------------------------------------------------------------
        // PHASE 1 — Volume Discovery
        // -------------------------------------------------------------------

        private static void Phase1_Discover(BakeContext ctx, BakeReport report)
        {
            // Defensive — already null-checked at entry, but Phase 1 is also responsible per the spec.
            if (ctx.Authoring == null)
            {
                report.Error("P1", "LevelAuthoring reference is null.");
                return;
            }

            var rootTransform = ctx.Authoring.transform;

            // Scoped scan: only volumes parented under _LevelAuthoring's transform are part of the bake.
            ctx.PlayerZoneVolumes = rootTransform.GetComponentsInChildren<PlayerZoneVolume>(includeInactive: false).ToList();
            ctx.SpawnerVolumes = rootTransform.GetComponentsInChildren<SpawnerVolume>(includeInactive: false).ToList();
            ctx.LeakExitVolumes = rootTransform.GetComponentsInChildren<LeakExitVolume>(includeInactive: false).ToList();
            ctx.GoalVolumes = rootTransform.GetComponentsInChildren<GoalVolume>(includeInactive: false).ToList();
            ctx.MapAreaVolumes = rootTransform.GetComponentsInChildren<MapAreaVolume>(includeInactive: false).ToList();

            ctx.AllVolumes = new List<VolumeBase>();
            ctx.AllVolumes.AddRange(ctx.PlayerZoneVolumes);
            ctx.AllVolumes.AddRange(ctx.SpawnerVolumes);
            ctx.AllVolumes.AddRange(ctx.LeakExitVolumes);
            ctx.AllVolumes.AddRange(ctx.GoalVolumes);
            ctx.AllVolumes.AddRange(ctx.MapAreaVolumes);

            // Full-scene scan: catch volumes that exist but aren't parented under _LevelAuthoring.
            var orphanCandidates = UnityEngine.Object.FindObjectsByType<VolumeBase>(FindObjectsInactive.Exclude);
            var includedSet = new HashSet<VolumeBase>(ctx.AllVolumes);
            foreach (var v in orphanCandidates)
            {
                if (v == null || includedSet.Contains(v)) continue;
                Debug.LogWarning($"[LevelAuthoring] Orphaned volume excluded from bake: '{v.name}' " +
                                 $"({v.GetType().Name}) is not parented under '{rootTransform.name}' and was skipped.");
            }

            // Canonical sort by hierarchy path with sibling-index disambiguation. Used for both the
            // hash input ordering and stable iteration in subsequent phases.
            ctx.AllVolumes.Sort((a, b) => string.CompareOrdinal(CanonicalPath(a, rootTransform), CanonicalPath(b, rootTransform)));
            ctx.PlayerZoneVolumes.Sort((a, b) => string.CompareOrdinal(CanonicalPath(a, rootTransform), CanonicalPath(b, rootTransform)));
            ctx.SpawnerVolumes.Sort((a, b) => string.CompareOrdinal(CanonicalPath(a, rootTransform), CanonicalPath(b, rootTransform)));
            ctx.LeakExitVolumes.Sort((a, b) => string.CompareOrdinal(CanonicalPath(a, rootTransform), CanonicalPath(b, rootTransform)));
            ctx.GoalVolumes.Sort((a, b) => string.CompareOrdinal(CanonicalPath(a, rootTransform), CanonicalPath(b, rootTransform)));
            ctx.MapAreaVolumes.Sort((a, b) => string.CompareOrdinal(CanonicalPath(a, rootTransform), CanonicalPath(b, rootTransform)));
        }

        // Builds the canonical path string for a transform, relative to the root, with sibling
        // indices appended to each segment. Example: "Spawners/Spawner[3]/Inner[0]".
        // Used for both the canonical sort and the hash input.
        private static string CanonicalPath(Component component, Transform root)
        {
            if (component == null) return "<null>";
            var t = component.transform;
            var segments = new List<string>();

            while (t != null && t != root)
            {
                int siblingIndex = t.GetSiblingIndex();
                segments.Add($"{t.name}[{siblingIndex}]");
                t = t.parent;
            }

            segments.Reverse();
            return string.Join("/", segments);
        }

        // -------------------------------------------------------------------
        // PHASE 2 — Pre-Validation (cheap checks, no tile rasterization yet)
        // -------------------------------------------------------------------

        private static readonly HashSet<int> ValidPlayerCounts = new HashSet<int> { 1, 2, 3, 4, 5, 9 };

        private static void Phase2_PreValidate(BakeContext ctx, BakeReport report)
        {
            var auth = ctx.Authoring;

            // P2-13: targetAsset is non-null
            if (auth.targetAsset == null)
            {
                report.Error("P2-13", "LevelAuthoring.targetAsset is not set. Assign a LevelData ScriptableObject before baking.");
            }

            // P2-14: mapName is non-empty
            if (string.IsNullOrWhiteSpace(auth.mapName))
            {
                report.Error("P2-14", "Map name is empty.");
            }

            // P2-15: playerCount is in {1, 2, 3, 4, 5, 9}
            if (!ValidPlayerCounts.Contains(auth.playerCount))
            {
                report.Error("P2-15", $"Player count must be one of {{1, 2, 3, 4, 5, 9}}; got {auth.playerCount}.");
            }

            // P2-2.5: expectedGoalCount >= 1
            if (auth.expectedGoalCount < 1)
            {
                report.Error("P2-2.5", $"expectedGoalCount must be ≥ 1; got {auth.expectedGoalCount}.");
            }

            // P2-2: GoalVolume count equals expectedGoalCount
            if (ctx.GoalVolumes.Count != auth.expectedGoalCount)
            {
                report.Error("P2-2", $"Found {ctx.GoalVolumes.Count} GoalVolume(s); LevelAuthoring expects {auth.expectedGoalCount}.");
            }

            // P2-22: at least one MapAreaVolume is present.
            // The map area is required (not inferred) so that gameplay bounds stay decoupled from
            // visual geometry. See "Lessons Learned" — inferring playable bounds from terrain
            // mesh extent was deliberately rejected.
            if (ctx.MapAreaVolumes.Count == 0)
            {
                report.Error("P2-22", "No MapAreaVolume found. Every map must have at least one " +
                                      "MapAreaVolume defining the playable bounds (where the builder " +
                                      "can move and the camera can pan).");
            }

            // P2-16: author non-empty (soft warning)
            if (string.IsNullOrWhiteSpace(auth.author))
            {
                report.Warning("P2-16", "Author field is empty.");
            }

            // P2-17: mapDescription non-empty (soft warning)
            if (string.IsNullOrWhiteSpace(auth.mapDescription))
            {
                report.Warning("P2-17", "Map description is empty.");
            }

            // -- Per-volume checks --

            // Build the set of declared player zones (owners present in the scene).
            var declaredOwners = new HashSet<PlayerSlot>();
            foreach (var z in ctx.PlayerZoneVolumes) declaredOwners.Add(z.owner);
            ctx.DeclaredOwners = declaredOwners;

            // Build the expected set of owners based on playerCount (Player1..PlayerN).
            var expectedOwners = new HashSet<PlayerSlot>();
            if (ValidPlayerCounts.Contains(auth.playerCount))
            {
                for (int i = 1; i <= auth.playerCount; i++) expectedOwners.Add((PlayerSlot)(byte)i);
            }
            ctx.ExpectedOwners = expectedOwners;

            // P2-1: every expected PlayerSlot has at least one PlayerZoneVolume
            foreach (var slot in expectedOwners)
            {
                if (!declaredOwners.Contains(slot))
                {
                    report.Error("P2-1", $"No PlayerZoneVolume found for {slot}.");
                }
            }

            // P2-6: no volume declares a PlayerSlot exceeding playerCount
            foreach (var z in ctx.PlayerZoneVolumes)
            {
                if (z.owner != PlayerSlot.None && (byte)z.owner > auth.playerCount)
                {
                    report.Error("P2-6", $"PlayerZoneVolume '{z.name}' owner is {z.owner} but playerCount is {auth.playerCount}.");
                }
            }
            foreach (var s in ctx.SpawnerVolumes)
            {
                if (s.owner != PlayerSlot.None && (byte)s.owner > auth.playerCount)
                {
                    report.Error("P2-6", $"SpawnerVolume '{s.name}' owner is {s.owner} but playerCount is {auth.playerCount}.");
                }
            }
            foreach (var l in ctx.LeakExitVolumes)
            {
                if (l.sourceZone != PlayerSlot.None && (byte)l.sourceZone > auth.playerCount)
                {
                    report.Error("P2-6", $"LeakExitVolume '{l.name}' sourceZone is {l.sourceZone} but playerCount is {auth.playerCount}.");
                }
                if (l.target != PlayerSlot.None && (byte)l.target > auth.playerCount)
                {
                    report.Error("P2-6", $"LeakExitVolume '{l.name}' target is {l.target} but playerCount is {auth.playerCount}.");
                }
            }

            // P2-3: every spawner.owner matches an existing player zone
            foreach (var s in ctx.SpawnerVolumes)
            {
                if (!declaredOwners.Contains(s.owner))
                {
                    report.Error("P2-3", $"SpawnerVolume '{s.name}' owner is {s.owner}, which has no PlayerZoneVolume.");
                }
            }

            // P2-4: every leak exit sourceZone matches an existing player zone
            // P2-5: every leak exit target matches an existing player zone
            foreach (var l in ctx.LeakExitVolumes)
            {
                if (!declaredOwners.Contains(l.sourceZone))
                {
                    report.Error("P2-4", $"LeakExitVolume '{l.name}' sourceZone is {l.sourceZone}, which has no PlayerZoneVolume.");
                }
                if (!declaredOwners.Contains(l.target))
                {
                    report.Error("P2-5", $"LeakExitVolume '{l.name}' target is {l.target}, which has no PlayerZoneVolume.");
                }
            }

            // P2-7: spawner IDs unique within their zone
            // P2-8: spawner IDs contiguous from 0 (soft warning)
            var spawnersByOwner = ctx.SpawnerVolumes
                .GroupBy(s => s.owner)
                .ToDictionary(g => g.Key, g => g.ToList());
            foreach (var kv in spawnersByOwner)
            {
                var ids = kv.Value.Select(s => s.spawnerIdInZone).ToList();
                var idSet = new HashSet<int>();
                foreach (var id in ids)
                {
                    if (!idSet.Add(id))
                    {
                        report.Error("P2-7", $"Spawner zone {kv.Key} has duplicate spawnerIdInZone={id}.");
                    }
                }
                ids.Sort();
                for (int i = 0; i < ids.Count; i++)
                {
                    if (ids[i] != i)
                    {
                        report.Warning("P2-8", $"Spawner zone {kv.Key} has non-contiguous IDs (sorted: [{string.Join(",", ids)}]). Expected 0..{ids.Count - 1}.");
                        break;
                    }
                }
            }

            // P2-11: leak weights for each source zone sum to non-zero
            var leaksBySource = ctx.LeakExitVolumes
                .GroupBy(l => l.sourceZone)
                .ToDictionary(g => g.Key, g => g.ToList());
            foreach (var kv in leaksBySource)
            {
                float total = 0f;
                foreach (var l in kv.Value) total += l.weight;
                if (total <= 0f)
                {
                    report.Error("P2-11", $"Leak exits for source zone {kv.Key} have non-positive total weight ({total}).");
                }
            }

            // P2-18: every volume's BoxCollider.bounds vertically contains Y=0
            foreach (var v in ctx.AllVolumes)
            {
                var col = v.GetComponent<BoxCollider>();
                if (col == null)
                {
                    report.Error("P2-18", $"Volume '{v.name}' has no BoxCollider.");
                    continue;
                }
                var b = col.bounds;
                if (b.min.y > 0f || b.max.y < 0f)
                {
                    report.Error("P2-18", $"Volume '{v.name}' bounds do not vertically contain Y=0 (Y range: {b.min.y:F2}..{b.max.y:F2}).");
                }
            }

            // P2-19: every volume's transform rotation is zero
            foreach (var v in ctx.AllVolumes)
            {
                Vector3 e = v.transform.eulerAngles;
                // Normalize to (-180..180] for comparison.
                float dx = NormalizeAngle(e.x);
                float dy = NormalizeAngle(e.y);
                float dz = NormalizeAngle(e.z);
                const float tol = 0.01f;
                if (Mathf.Abs(dx) > tol || Mathf.Abs(dy) > tol || Mathf.Abs(dz) > tol)
                {
                    report.Error("P2-19", $"Volume '{v.name}' has non-zero rotation ({e}). Volumes must be axis-aligned.");
                }
            }

            // P2-21: every volume's transform.localScale equals (1, 1, 1) (soft warning)
            foreach (var v in ctx.AllVolumes)
            {
                Vector3 s = v.transform.localScale;
                const float tol = 0.0001f;
                if (Mathf.Abs(s.x - 1f) > tol || Mathf.Abs(s.y - 1f) > tol || Mathf.Abs(s.z - 1f) > tol)
                {
                    report.Warning("P2-21", $"Volume '{v.name}' has non-unit transform.localScale ({s}). Use BoxCollider.Size for sizing instead of Transform.Scale to avoid tile-snapping issues.");
                }
            }

            // P2-20 is checked in Phase 3 (it requires tile-rasterized aggregate bounds).
        }

        private static float NormalizeAngle(float a)
        {
            a = a % 360f;
            if (a > 180f) a -= 360f;
            else if (a < -180f) a += 360f;
            return a;
        }

        // -------------------------------------------------------------------
        // PHASE 3 — Tile Rasterization
        // -------------------------------------------------------------------

        private static void Phase3_Rasterize(BakeContext ctx, BakeReport report)
        {
            ctx.PerVolumeTiles = new Dictionary<VolumeBase, HashSet<Vector2Int>>();
            ctx.PerOwnerZoneTiles = new Dictionary<PlayerSlot, HashSet<Vector2Int>>();
            ctx.PerGoalTiles = new List<HashSet<Vector2Int>>();
            ctx.MapAreaTiles = new HashSet<Vector2Int>();

            bool initializedAggregate = false;
            int aggMinX = 0, aggMinY = 0, aggMaxX = 0, aggMaxY = 0;

            foreach (var v in ctx.AllVolumes)
            {
                var col = v.GetComponent<BoxCollider>();
                if (col == null) continue; // Already errored in P2-18

                var tiles = new HashSet<Vector2Int>();
                VolumeBase.RasterizeBoundsToTiles(col.bounds, t => tiles.Add(t));

                if (tiles.Count == 0)
                {
                    // Defensive backstop — most causes are caught by P2-18 (Y=0 containment),
                    // but a degenerate-size collider (e.g. Size = 0) produces an empty tile set
                    // that the spec also rejects.
                    report.Error("P3", $"Volume '{v.name}' rasterized to zero tiles. " +
                                       "Check that the BoxCollider has non-zero Size and its bounds vertically intersect Y=0.");
                    continue;
                }

                ctx.PerVolumeTiles[v] = tiles;

                // Update aggregate map bounds.
                foreach (var t in tiles)
                {
                    if (!initializedAggregate)
                    {
                        aggMinX = aggMaxX = t.x;
                        aggMinY = aggMaxY = t.y;
                        initializedAggregate = true;
                    }
                    else
                    {
                        if (t.x < aggMinX) aggMinX = t.x;
                        if (t.x > aggMaxX) aggMaxX = t.x;
                        if (t.y < aggMinY) aggMinY = t.y;
                        if (t.y > aggMaxY) aggMaxY = t.y;
                    }
                }

                // Aggregate per-owner zone tile sets.
                if (v is PlayerZoneVolume zone)
                {
                    if (!ctx.PerOwnerZoneTiles.TryGetValue(zone.owner, out var ownerSet))
                    {
                        ownerSet = new HashSet<Vector2Int>();
                        ctx.PerOwnerZoneTiles[zone.owner] = ownerSet;
                    }
                    foreach (var t in tiles) ownerSet.Add(t);
                }

                // Goals: one tile set per goal (NOT unioned).
                if (v is GoalVolume)
                {
                    ctx.PerGoalTiles.Add(tiles);
                }

                // Map area: union all MapAreaVolume tiles into a single set. The map area is the
                // union of all MapAreaVolumes, so a tile is "in the map" if ANY MapAreaVolume
                // covers it.
                if (v is MapAreaVolume)
                {
                    foreach (var t in tiles) ctx.MapAreaTiles.Add(t);
                }
            }

            if (!initializedAggregate)
            {
                report.Error("P3", "No volumes rasterized to any tiles. The map is empty.");
                return;
            }

            ctx.MapMinTile = new Vector2Int(aggMinX, aggMinY);
            ctx.MapMaxTile = new Vector2Int(aggMaxX, aggMaxY);

            // P2-20: map's tile bounding rect's min corner is (0, 0). Soft warning.
            // (Checked here because it requires the rasterized aggregate bounds.)
            if (ctx.MapMinTile.x != 0 || ctx.MapMinTile.y != 0)
            {
                report.Warning("P2-20", $"Map's southwest corner is at tile {ctx.MapMinTile}, not (0, 0). " +
                                        "Convention is for tile (0,0) to be the southwest corner of the map.");
            }
        }

        // -------------------------------------------------------------------
        // PHASE 4 — Grid Composition
        // -------------------------------------------------------------------

        private static void Phase4_ComposeGrids(BakeContext ctx, BakeReport report)
        {
            ctx.GridOriginTile = ctx.MapMinTile;
            ctx.GridSize = new Vector2Int(
                ctx.MapMaxTile.x - ctx.MapMinTile.x + 1,
                ctx.MapMaxTile.y - ctx.MapMinTile.y + 1);

            int width = ctx.GridSize.x;
            int height = ctx.GridSize.y;

            // 2D arrays during composition; flattened to 1D in Phase 6.
            ctx.PlacementGrid2D = new PlacementState[width, height];   // defaults to Outside (0)
            ctx.WalkabilityGrid2D = new bool[width, height];           // defaults to false
            ctx.MapAreaGrid2D = new bool[width, height];               // defaults to false

            // Map-area composition: a tile is "in map" iff any MapAreaVolume covers it. We have
            // the union pre-computed in ctx.MapAreaTiles from Phase 3.
            foreach (var t in ctx.MapAreaTiles)
            {
                int gx = t.x - ctx.GridOriginTile.x;
                int gy = t.y - ctx.GridOriginTile.y;
                ctx.MapAreaGrid2D[gx, gy] = true;
            }

            // Volume-iterating algorithm: O(total tile-coverage) rather than O(grid * volumes).
            foreach (var v in ctx.AllVolumes)
            {
                if (!ctx.PerVolumeTiles.TryGetValue(v, out var tiles)) continue;

                // MapAreaVolume contributes ONLY to the map-area grid (handled above) — not to
                // walkability or placement. Buffer tiles (in-map but not gameplay) must remain
                // non-walkable so enemies cannot path through them.
                if (v is MapAreaVolume) continue;

                bool isInvalid = IsInvalidValidity(v);
                bool isPlayerZone = v is PlayerZoneVolume;

                foreach (var tile in tiles)
                {
                    int gx = tile.x - ctx.GridOriginTile.x;
                    int gy = tile.y - ctx.GridOriginTile.y;
                    // bounds always within [0..size) by construction (aggregate min/max inclusive).

                    // All volume tiles are walkable initially.
                    ctx.WalkabilityGrid2D[gx, gy] = true;

                    // Placement composition: "Invalid wins". Once a tile is Restricted, it stays Restricted.
                    if (isInvalid)
                    {
                        ctx.PlacementGrid2D[gx, gy] = PlacementState.Restricted;
                    }
                    else if (isPlayerZone && ctx.PlacementGrid2D[gx, gy] != PlacementState.Restricted)
                    {
                        ctx.PlacementGrid2D[gx, gy] = PlacementState.Buildable;
                    }
                }
            }
        }

        private static bool IsInvalidValidity(VolumeBase v)
        {
            // PlayerZoneVolume.placementValidity defaults to Allowed; others default to Invalid.
            // We check the field on each subclass.
            switch (v)
            {
                case PlayerZoneVolume pz: return pz.placementValidity == PlacementValidity.Invalid;
                case SpawnerVolume sv: return sv.placementValidity == PlacementValidity.Invalid;
                case LeakExitVolume lv: return lv.placementValidity == PlacementValidity.Invalid;
                case GoalVolume gv: return gv.placementValidity == PlacementValidity.Invalid;
                default: return false;
            }
        }

        // -------------------------------------------------------------------
        // PHASE 5 — Spatial Validation
        // -------------------------------------------------------------------

        private static void Phase5_SpatialValidate(BakeContext ctx, BakeReport report)
        {
            // P5-1: no PlayerZoneVolumes with different owners overlap.
            // For each tile in any zone, track which owners cover it.
            var tileToOwners = new Dictionary<Vector2Int, HashSet<PlayerSlot>>();
            foreach (var z in ctx.PlayerZoneVolumes)
            {
                if (!ctx.PerVolumeTiles.TryGetValue(z, out var tiles)) continue;
                foreach (var t in tiles)
                {
                    if (!tileToOwners.TryGetValue(t, out var owners))
                    {
                        owners = new HashSet<PlayerSlot>();
                        tileToOwners[t] = owners;
                    }
                    owners.Add(z.owner);
                }
            }
            foreach (var kv in tileToOwners)
            {
                if (kv.Value.Count > 1)
                {
                    var ownersList = string.Join(", ", kv.Value);
                    report.Error("P5-1", $"Tile {kv.Key} is covered by multiple PlayerZoneVolumes with different owners: {ownersList}.");
                }
            }

            // Build per-goal tile lookup. P5-2 and P5-3 use this.
            var goalTileToIdx = new Dictionary<Vector2Int, int>();
            for (int g = 0; g < ctx.PerGoalTiles.Count; g++)
            {
                foreach (var t in ctx.PerGoalTiles[g])
                {
                    if (goalTileToIdx.TryGetValue(t, out int otherIdx))
                    {
                        // P5-3
                        if (otherIdx != g)
                        {
                            report.Error("P5-3", $"Tile {t} is covered by multiple GoalVolumes (goal #{otherIdx} and goal #{g}).");
                        }
                    }
                    else
                    {
                        goalTileToIdx[t] = g;
                    }
                }
            }

            // P5-2: no PlayerZoneVolume overlaps a GoalVolume
            foreach (var t in tileToOwners.Keys)
            {
                if (goalTileToIdx.ContainsKey(t))
                {
                    report.Error("P5-2", $"Tile {t} is covered by both a PlayerZoneVolume and a GoalVolume.");
                }
            }

            // Build a unified set of all walkable tiles (for BFS connectivity).
            var walkableSet = new HashSet<Vector2Int>();
            for (int x = 0; x < ctx.GridSize.x; x++)
            {
                for (int y = 0; y < ctx.GridSize.y; y++)
                {
                    if (ctx.WalkabilityGrid2D[x, y])
                    {
                        walkableSet.Add(new Vector2Int(x + ctx.GridOriginTile.x, y + ctx.GridOriginTile.y));
                    }
                }
            }

            // P5-10: walkability grid is non-empty
            if (walkableSet.Count == 0)
            {
                report.Error("P5-10", "Walkability grid is empty — no tiles are walkable.");
                return;
            }

            // Build the set of "exit" tiles: any leak exit tile, OR any goal tile.
            var exitTiles = new HashSet<Vector2Int>();
            foreach (var l in ctx.LeakExitVolumes)
            {
                if (!ctx.PerVolumeTiles.TryGetValue(l, out var tiles)) continue;
                foreach (var t in tiles) exitTiles.Add(t);
            }
            foreach (var t in goalTileToIdx.Keys) exitTiles.Add(t);

            // P5-4: every spawner's tiles reach an exit via walkability BFS.
            // Use a single shared queue to avoid allocations across spawners.
            var bfsQueue = new Queue<Vector2Int>();
            var bfsVisited = new HashSet<Vector2Int>();
            foreach (var s in ctx.SpawnerVolumes)
            {
                if (!ctx.PerVolumeTiles.TryGetValue(s, out var spawnerTiles) || spawnerTiles.Count == 0) continue;

                bfsQueue.Clear();
                bfsVisited.Clear();
                foreach (var t in spawnerTiles)
                {
                    bfsQueue.Enqueue(t);
                    bfsVisited.Add(t);
                }

                bool reachedExit = false;
                while (bfsQueue.Count > 0)
                {
                    var t = bfsQueue.Dequeue();
                    if (exitTiles.Contains(t)) { reachedExit = true; break; }

                    // 8-connected with corner-cut prevention — must match the
                    // runtime PathfindingService / TowerPlacementManager rules.
                    foreach (var n in GridCoordinates.GetNeighbors8(t))
                    {
                        if (bfsVisited.Contains(n)) continue;
                        if (!walkableSet.Contains(n)) continue;

                        if (GridCoordinates.IsDiagonal(t, n))
                        {
                            GridCoordinates.GetCornerShoulders(t, n,
                                out var shoulderA, out var shoulderB);
                            if (!walkableSet.Contains(shoulderA) || !walkableSet.Contains(shoulderB))
                                continue;
                        }

                        bfsVisited.Add(n);
                        bfsQueue.Enqueue(n);
                    }
                }

                if (!reachedExit)
                {
                    report.Error("P5-4", $"SpawnerVolume '{s.name}' (owner {s.owner}, id {s.spawnerIdInZone}) cannot reach any leak exit or goal via walkability.");
                }
            }

            // P5-5: spawner's tiles inside its declared owner's zone (soft warning).
            foreach (var s in ctx.SpawnerVolumes)
            {
                if (!ctx.PerVolumeTiles.TryGetValue(s, out var spawnerTiles)) continue;
                if (!ctx.PerOwnerZoneTiles.TryGetValue(s.owner, out var ownerZoneTiles))
                {
                    // owner not declared — already errored in P2-3
                    continue;
                }
                foreach (var t in spawnerTiles)
                {
                    if (!ownerZoneTiles.Contains(t))
                    {
                        report.Warning("P5-5", $"SpawnerVolume '{s.name}' (owner {s.owner}) has tile {t} outside owner's PlayerZoneVolume coverage.");
                        break; // only report once per spawner
                    }
                }
            }

            // P5-6: every leak exit's tiles 4-adjacent to its target zone's tiles.
            // P5-7: every leak exit's tiles 4-adjacent to its source zone's tiles.
            foreach (var l in ctx.LeakExitVolumes)
            {
                if (!ctx.PerVolumeTiles.TryGetValue(l, out var leakTiles)) continue;

                bool hasSourceAdj = false;
                bool hasTargetAdj = false;

                ctx.PerOwnerZoneTiles.TryGetValue(l.sourceZone, out var sourceTiles);
                ctx.PerOwnerZoneTiles.TryGetValue(l.target, out var targetTiles);

                if (sourceTiles != null && targetTiles != null)
                {
                    foreach (var t in leakTiles)
                    {
                        foreach (var n in GridCoordinates.GetNeighbors(t))
                        {
                            if (!hasSourceAdj && sourceTiles.Contains(n)) hasSourceAdj = true;
                            if (!hasTargetAdj && targetTiles.Contains(n)) hasTargetAdj = true;
                            if (hasSourceAdj && hasTargetAdj) break;
                        }
                        if (hasSourceAdj && hasTargetAdj) break;
                    }
                }

                if (sourceTiles != null && !hasSourceAdj)
                {
                    report.Error("P5-7", $"LeakExitVolume '{l.name}' is not 4-adjacent to its sourceZone {l.sourceZone}.");
                }
                if (targetTiles != null && !hasTargetAdj)
                {
                    report.Error("P5-6", $"LeakExitVolume '{l.name}' is not 4-adjacent to its target {l.target}.");
                }
            }

            // P5-9: at least one player zone is goal-adjacent.
            // P5-8: every player zone has outgoing leak OR is goal-adjacent.
            var goalAdjacentZones = new HashSet<PlayerSlot>();
            var allGoalTiles = new HashSet<Vector2Int>(goalTileToIdx.Keys);

            foreach (var kv in ctx.PerOwnerZoneTiles)
            {
                bool isGoalAdjacent = false;
                foreach (var t in kv.Value)
                {
                    foreach (var n in GridCoordinates.GetNeighbors(t))
                    {
                        if (allGoalTiles.Contains(n)) { isGoalAdjacent = true; break; }
                    }
                    if (isGoalAdjacent) break;
                }
                if (isGoalAdjacent) goalAdjacentZones.Add(kv.Key);
            }

            ctx.GoalAdjacentZones = goalAdjacentZones;

            if (goalAdjacentZones.Count == 0)
            {
                report.Error("P5-9", "No player zone is goal-adjacent. At least one zone must be 4-adjacent to a GoalVolume.");
            }

            // P5-8: zones with neither outgoing leak nor goal adjacency.
            var zonesWithLeaks = new HashSet<PlayerSlot>();
            foreach (var l in ctx.LeakExitVolumes) zonesWithLeaks.Add(l.sourceZone);

            foreach (var owner in ctx.DeclaredOwners)
            {
                bool hasLeak = zonesWithLeaks.Contains(owner);
                bool isGoalAdj = goalAdjacentZones.Contains(owner);
                if (!hasLeak && !isGoalAdj)
                {
                    report.Error("P5-8", $"Player zone {owner} has no outgoing leak exit AND is not goal-adjacent. " +
                                         "Every zone must either lead somewhere or be a final defender.");
                }
            }

            // P5-11: no isolated walkable regions (soft warning).
            // Connected-component count over the walkable set; warn if more than one component.
            int components = CountWalkableComponents(walkableSet);
            if (components > 1)
            {
                report.Warning("P5-11", $"Walkability grid has {components} disconnected regions. " +
                                        "Some areas of the map are unreachable from others.");
            }

            // P5-12: every gameplay volume's tiles must be a subset of the map area.
            // Coverage rule from the design spec — gameplay can't poke outside the playable map.
            // Skipped if no MapAreaVolume exists (P2-22 already errored; this would just spam).
            if (ctx.MapAreaTiles.Count > 0)
            {
                ValidateGameplayContainedInMapArea(ctx, report);
            }
        }

        // P5-12: each gameplay volume (PlayerZone, Spawner, LeakExit, Goal) must have all its
        // tiles inside ctx.MapAreaTiles. Reports one error per offending volume with the count of
        // out-of-map tiles to avoid drowning the report in per-tile errors.
        private static void ValidateGameplayContainedInMapArea(BakeContext ctx, BakeReport report)
        {
            foreach (var v in ctx.AllVolumes)
            {
                if (v is MapAreaVolume) continue; // The map area itself doesn't need to contain itself.
                if (!ctx.PerVolumeTiles.TryGetValue(v, out var tiles)) continue;

                int outsideCount = 0;
                Vector2Int firstOutside = Vector2Int.zero;
                foreach (var t in tiles)
                {
                    if (!ctx.MapAreaTiles.Contains(t))
                    {
                        if (outsideCount == 0) firstOutside = t;
                        outsideCount++;
                    }
                }

                if (outsideCount > 0)
                {
                    report.Error("P5-12",
                        $"{v.GetType().Name} '{v.name}' has {outsideCount} tile(s) outside the map area " +
                        $"(first offender: {firstOutside}). Every gameplay volume must be fully contained " +
                        "within the union of MapAreaVolumes.");
                }
            }
        }

        private static int CountWalkableComponents(HashSet<Vector2Int> walkable)
        {
            var visited = new HashSet<Vector2Int>();
            int components = 0;
            var queue = new Queue<Vector2Int>();

            foreach (var seed in walkable)
            {
                if (visited.Contains(seed)) continue;
                components++;
                queue.Clear();
                queue.Enqueue(seed);
                visited.Add(seed);

                while (queue.Count > 0)
                {
                    var t = queue.Dequeue();
                    // 8-connected with corner-cut prevention — keeps component
                    // counting consistent with pathfinding semantics.
                    foreach (var n in GridCoordinates.GetNeighbors8(t))
                    {
                        if (visited.Contains(n)) continue;
                        if (!walkable.Contains(n)) continue;

                        if (GridCoordinates.IsDiagonal(t, n))
                        {
                            GridCoordinates.GetCornerShoulders(t, n,
                                out var shoulderA, out var shoulderB);
                            if (!walkable.Contains(shoulderA) || !walkable.Contains(shoulderB))
                                continue;
                        }

                        visited.Add(n);
                        queue.Enqueue(n);
                    }
                }
            }
            return components;
        }

        // -------------------------------------------------------------------
        // PHASE 6 — Output Assembly
        // -------------------------------------------------------------------

        private static void Phase6_AssembleOutput(BakeContext ctx, BakeReport report)
        {
            // Build the in-memory LevelData. We populate a fresh instance and then field-by-field
            // copy onto targetAsset in Phase 7 (preserves the asset's GUID).
            var data = ScriptableObject.CreateInstance<LevelData>();

            data.MapName = ctx.Authoring.mapName;
            data.PlayerCount = ctx.Authoring.playerCount;
            data.MapDescription = ctx.Authoring.mapDescription;
            data.Author = ctx.Authoring.author;
            data.GridOriginTile = ctx.GridOriginTile;
            data.GridSize = ctx.GridSize;

            // Flatten 2D grids to 1D row-major arrays.
            int width = ctx.GridSize.x;
            int height = ctx.GridSize.y;
            int total = width * height;

            data.PlacementGrid = new PlacementState[total];
            data.WalkabilityGrid = new bool[total];
            data.OwnerGrid = new PlayerSlot[total]; // defaults to PlayerSlot.None (=0)
            data.MapAreaGrid = new bool[total];     // defaults to false

            for (int x = 0; x < width; x++)
            {
                for (int y = 0; y < height; y++)
                {
                    int idx = y * width + x;
                    data.PlacementGrid[idx] = ctx.PlacementGrid2D[x, y];
                    data.WalkabilityGrid[idx] = ctx.WalkabilityGrid2D[x, y];
                    data.MapAreaGrid[idx] = ctx.MapAreaGrid2D[x, y];
                }
            }

            // Populate OwnerGrid from per-owner zone tile sets.
            foreach (var kv in ctx.PerOwnerZoneTiles)
            {
                foreach (var tile in kv.Value)
                {
                    int gx = tile.x - ctx.GridOriginTile.x;
                    int gy = tile.y - ctx.GridOriginTile.y;
                    if (gx < 0 || gx >= width || gy < 0 || gy >= height) continue;
                    data.OwnerGrid[gy * width + gx] = kv.Key;
                }
            }

            // Assemble PlayerZoneData[] sorted by Owner (PlayerSlot enum value).
            var declaredOrdered = ctx.DeclaredOwners.OrderBy(o => (byte)o).ToList();
            data.PlayerZones = new PlayerZoneData[declaredOrdered.Count];

            for (int i = 0; i < declaredOrdered.Count; i++)
            {
                PlayerSlot owner = declaredOrdered[i];
                var zoneData = new PlayerZoneData { Owner = owner };

                // Spawners for this owner, sorted by SpawnerIdInZone.
                var ownerSpawners = ctx.SpawnerVolumes
                    .Where(s => s.owner == owner)
                    .OrderBy(s => s.spawnerIdInZone)
                    .ToList();

                zoneData.Spawners = new SpawnerData[ownerSpawners.Count];
                for (int j = 0; j < ownerSpawners.Count; j++)
                {
                    var sv = ownerSpawners[j];
                    var col = sv.GetComponent<BoxCollider>();
                    Vector2Int pos = col != null
                        ? GridCoordinates.WorldToGrid(new Vector2(col.bounds.center.x, col.bounds.center.z))
                        : Vector2Int.zero;
                    Vector2Int[] tileArea = ctx.PerVolumeTiles.TryGetValue(sv, out var spawnerTiles)
                        ? spawnerTiles.OrderBy(t => t.y).ThenBy(t => t.x).ToArray()
                        : new Vector2Int[0];

                    zoneData.Spawners[j] = new SpawnerData
                    {
                        SpawnerIdInZone = sv.spawnerIdInZone,
                        TilePosition = pos,
                        TileArea = tileArea,
                        Facing = sv.spawnFacing,
                    };
                }

                // Leak exits FROM this owner's zone, sorted by Target enum value.
                var ownerLeaks = ctx.LeakExitVolumes
                    .Where(l => l.sourceZone == owner)
                    .OrderBy(l => (byte)l.target)
                    .ToList();

                // Normalize weights within this source zone.
                float totalWeight = 0f;
                foreach (var l in ownerLeaks) totalWeight += l.weight;
                // Already validated > 0 in P2-11 if there are any leaks.

                zoneData.LeakExits = new LeakExitData[ownerLeaks.Count];
                for (int j = 0; j < ownerLeaks.Count; j++)
                {
                    var lv = ownerLeaks[j];
                    Vector2Int[] tileArea = ctx.PerVolumeTiles.TryGetValue(lv, out var leakTiles)
                        ? leakTiles.OrderBy(t => t.y).ThenBy(t => t.x).ToArray()
                        : new Vector2Int[0];

                    zoneData.LeakExits[j] = new LeakExitData
                    {
                        Target = lv.target,
                        TileArea = tileArea,
                        NormalizedWeight = totalWeight > 0f ? lv.weight / totalWeight : 0f,
                    };
                }

                data.PlayerZones[i] = zoneData;
            }

            // Assemble GoalData[] sorted by min tile coordinate.
            var goalsList = new List<GoalData>(ctx.PerGoalTiles.Count);
            foreach (var goalTiles in ctx.PerGoalTiles)
            {
                Vector2Int[] tileArea = goalTiles.OrderBy(t => t.y).ThenBy(t => t.x).ToArray();
                goalsList.Add(new GoalData { TileArea = tileArea });
            }
            // Sort by min tile coordinate (lex on min Y, then min X).
            goalsList.Sort((a, b) =>
            {
                Vector2Int aMin = MinTile(a.TileArea);
                Vector2Int bMin = MinTile(b.TileArea);
                int c = aMin.y.CompareTo(bMin.y);
                if (c != 0) return c;
                return aMin.x.CompareTo(bMin.x);
            });
            data.Goals = goalsList.ToArray();

            // Compute authoring hash from canonical input string.
            data.AuthoringHash = ComputeAuthoringHash(ctx);

            // Populate ScenePath from the active scene.
            data.ScenePath = EditorSceneManager.GetActiveScene().path;

            // Bake metadata.
            data.LastBakeTimestamp = DateTime.UtcNow.ToString("o", CultureInfo.InvariantCulture);
            data.LastBakeOutcome = report.WarningCount > 0 ? BakeOutcome.SuccessWithWarnings : BakeOutcome.Success;
            data.LastBakeWarningCount = report.WarningCount;

            // Render thumbnail (best-effort; failure logs warning, doesn't abort).
            string assetPath = AssetDatabase.GetAssetPath(ctx.Authoring.targetAsset);
            string thumbnailPath = ComputeThumbnailPath(assetPath);
            try
            {
                if (RenderThumbnail(ctx, thumbnailPath))
                {
                    ctx.ThumbnailPath = thumbnailPath;
                }
                else
                {
                    report.Warning("P6", "Thumbnail render did not produce a file. Continuing without thumbnail.");
                }
            }
            catch (Exception e)
            {
                report.Warning("P6", $"Thumbnail render failed: {e.Message}. Continuing without thumbnail.");
            }

            ctx.AssembledData = data;
        }

        private static Vector2Int MinTile(Vector2Int[] tiles)
        {
            if (tiles == null || tiles.Length == 0) return Vector2Int.zero;
            int minX = tiles[0].x, minY = tiles[0].y;
            for (int i = 1; i < tiles.Length; i++)
            {
                if (tiles[i].x < minX) minX = tiles[i].x;
                if (tiles[i].y < minY) minY = tiles[i].y;
            }
            return new Vector2Int(minX, minY);
        }

        // -- Hash computation -------------------------------------------------

        /// <summary>
        /// Computes the authoring hash for a LevelAuthoring's scene state,
        /// suitable for comparing against <see cref="LevelData.AuthoringHash"/>
        /// to detect drift from baked data.
        /// </summary>
        /// <remarks>
        /// Delegates to the same hashing routine the bake itself uses, so equal
        /// hashes mean the scene would bake to equivalent LevelData. Hashes
        /// only Layer 1 authoring inputs (volumes + metadata); visual scene
        /// content (terrain, lighting, decorations) is NOT included.
        ///
        /// Performs its own volume discovery and canonical sort. Does NOT run
        /// pre-validation or rasterization, so it returns a hash even for scenes
        /// that would fail the bake (e.g. missing zones, overlapping volumes).
        /// That's intentional: the play-mode hook needs a hash even when the
        /// scene is broken, so it can report "drift" as the actionable problem
        /// rather than silently differing from the last successful bake.
        /// </remarks>
        public static string ComputeAuthoringHash(LevelAuthoring authoring)
        {
            if (authoring == null)
                return string.Empty;

            // Build a minimal BakeContext with just the fields the hash routine
            // reads: Authoring and AllVolumes. We mirror Phase 1's discovery
            // logic exactly (scoped scan + canonical sort) so the standalone
            // hash is identical to what Phase 1 would produce on the same scene.
            var ctx = new BakeContext { Authoring = authoring };
            var rootTransform = authoring.transform;

            var playerZones = rootTransform.GetComponentsInChildren<PlayerZoneVolume>(includeInactive: false);
            var spawners = rootTransform.GetComponentsInChildren<SpawnerVolume>(includeInactive: false);
            var leakExits = rootTransform.GetComponentsInChildren<LeakExitVolume>(includeInactive: false);
            var goals = rootTransform.GetComponentsInChildren<GoalVolume>(includeInactive: false);
            var mapAreas = rootTransform.GetComponentsInChildren<MapAreaVolume>(includeInactive: false);

            ctx.AllVolumes = new System.Collections.Generic.List<VolumeBase>(
                playerZones.Length + spawners.Length + leakExits.Length + goals.Length + mapAreas.Length);
            ctx.AllVolumes.AddRange(playerZones);
            ctx.AllVolumes.AddRange(spawners);
            ctx.AllVolumes.AddRange(leakExits);
            ctx.AllVolumes.AddRange(goals);
            ctx.AllVolumes.AddRange(mapAreas);

            // Match Phase 1's canonical sort exactly. The hash routine re-orders
            // by canonical path internally, but sorting AllVolumes here keeps
            // the data flow identical to Phase 1, so any future change to the
            // discovery/sort step is automatically picked up.
            ctx.AllVolumes.Sort((a, b) => string.CompareOrdinal(
                CanonicalPath(a, rootTransform),
                CanonicalPath(b, rootTransform)));

            return ComputeAuthoringHash(ctx);
        }

        private static string ComputeAuthoringHash(BakeContext ctx)
        {
            var sb = new StringBuilder();
            CultureInfo inv = CultureInfo.InvariantCulture;

            // LevelAuthoring metadata block.
            sb.Append("LA|");
            sb.Append("mapName=").Append(ctx.Authoring.mapName ?? "").Append('|');
            sb.Append("playerCount=").Append(ctx.Authoring.playerCount.ToString(inv)).Append('|');
            sb.Append("expectedGoalCount=").Append(ctx.Authoring.expectedGoalCount.ToString(inv)).Append('|');
            sb.Append("mapDescription=").Append(ctx.Authoring.mapDescription ?? "").Append('|');
            sb.Append("author=").Append(ctx.Authoring.author ?? "").Append('\n');

            // Volume blocks, ordered by canonical path.
            var rootTransform = ctx.Authoring.transform;
            var ordered = ctx.AllVolumes
                .Select(v => (volume: v, path: CanonicalPath(v, rootTransform)))
                .OrderBy(x => x.path, StringComparer.Ordinal)
                .ToList();

            foreach (var (v, path) in ordered)
            {
                sb.Append("V|");
                sb.Append("type=").Append(v.GetType().Name).Append('|');
                sb.Append("path=").Append(path).Append('|');

                var col = v.GetComponent<BoxCollider>();
                if (col != null)
                {
                    Bounds b = col.bounds;
                    sb.Append("center=")
                      .Append(b.center.x.ToString("G17", inv)).Append(',')
                      .Append(b.center.y.ToString("G17", inv)).Append(',')
                      .Append(b.center.z.ToString("G17", inv)).Append('|');
                    sb.Append("size=")
                      .Append(b.size.x.ToString("G17", inv)).Append(',')
                      .Append(b.size.y.ToString("G17", inv)).Append(',')
                      .Append(b.size.z.ToString("G17", inv)).Append('|');
                }

                // Per-subtype fields. Enum values by NAME, not numeric value.
                switch (v)
                {
                    case PlayerZoneVolume pz:
                        sb.Append("owner=").Append(pz.owner.ToString()).Append('|');
                        sb.Append("validity=").Append(pz.placementValidity.ToString()).Append('|');
                        break;
                    case SpawnerVolume sv:
                        sb.Append("owner=").Append(sv.owner.ToString()).Append('|');
                        sb.Append("id=").Append(sv.spawnerIdInZone.ToString(inv)).Append('|');
                        sb.Append("facing=").Append(sv.spawnFacing.ToString()).Append('|');
                        sb.Append("validity=").Append(sv.placementValidity.ToString()).Append('|');
                        break;
                    case LeakExitVolume lv:
                        sb.Append("source=").Append(lv.sourceZone.ToString()).Append('|');
                        sb.Append("target=").Append(lv.target.ToString()).Append('|');
                        sb.Append("weight=").Append(lv.weight.ToString("G17", inv)).Append('|');
                        sb.Append("validity=").Append(lv.placementValidity.ToString()).Append('|');
                        break;
                    case GoalVolume gv:
                        sb.Append("validity=").Append(gv.placementValidity.ToString()).Append('|');
                        break;
                }
                sb.Append('\n');
            }

            // SHA256 of UTF-8 bytes.
            byte[] bytes = Encoding.UTF8.GetBytes(sb.ToString());
            using (var sha = SHA256.Create())
            {
                byte[] hash = sha.ComputeHash(bytes);
                var hex = new StringBuilder(hash.Length * 2);
                for (int i = 0; i < hash.Length; i++) hex.Append(hash[i].ToString("x2", inv));
                return hex.ToString();
            }
        }

        // -- Thumbnail rendering ---------------------------------------------

        private static string ComputeThumbnailPath(string assetPath)
        {
            // Asset path looks like "Assets/_Project/Scenes/Levels/MyMap.asset". Strip extension,
            // append "_Thumbnail.png".
            string dir = Path.GetDirectoryName(assetPath) ?? "Assets";
            string nameNoExt = Path.GetFileNameWithoutExtension(assetPath);
            return Path.Combine(dir, nameNoExt + "_Thumbnail.png").Replace("\\", "/");
        }

        private static bool RenderThumbnail(BakeContext ctx, string thumbnailAssetPath)
        {
            // Compute world-space bounds of the map's tile region.
            float halfTile = GridCoordinates.TILE_SIZE * 0.5f;
            float minX = ctx.MapMinTile.x - halfTile;
            float maxX = ctx.MapMaxTile.x + halfTile;
            float minZ = ctx.MapMinTile.y - halfTile;
            float maxZ = ctx.MapMaxTile.y + halfTile;
            float worldW = maxX - minX;
            float worldH = maxZ - minZ;

            // Aspect-matched non-square render with longer side at 1024px.
            int rtWidth, rtHeight;
            if (worldW >= worldH)
            {
                rtWidth = 1024;
                rtHeight = Mathf.Max(1, Mathf.RoundToInt(1024f * (worldH / worldW)));
            }
            else
            {
                rtHeight = 1024;
                rtWidth = Mathf.Max(1, Mathf.RoundToInt(1024f * (worldW / worldH)));
            }

            // Hide _LevelAuthoring subtree during the render so volume gizmos don't show up
            // (gizmos won't render in offscreen captures anyway, but child GameObjects with
            // visible meshes — labeling helpers, debug cubes etc. — would).
            var authGO = ctx.Authoring.gameObject;
            bool wasActive = authGO.activeSelf;
            authGO.SetActive(false);

            GameObject camGO = null;
            RenderTexture rt = null;
            RenderTexture prevActive = RenderTexture.active;
            Texture2D snapshot = null;
            try
            {
                rt = new RenderTexture(rtWidth, rtHeight, 24, RenderTextureFormat.ARGB32);
                rt.antiAliasing = 4;

                camGO = new GameObject("__BakeThumbnailCamera");
                camGO.hideFlags = HideFlags.HideAndDontSave;
                var cam = camGO.AddComponent<Camera>();
                cam.clearFlags = CameraClearFlags.SolidColor;
                cam.backgroundColor = new Color(0.15f, 0.15f, 0.18f, 1f);
                cam.orthographic = true;
                // orthographicSize is HALF the vertical world extent. We sized the render texture
                // so that aspect = worldW/worldH, which makes the camera's horizontal world extent
                // exactly worldW when the vertical extent is worldH. So setting size = worldH/2
                // makes the map fit exactly in both branches.
                cam.orthographicSize = worldH * 0.5f;
                // Center camera above map.
                float camX = (minX + maxX) * 0.5f;
                float camZ = (minZ + maxZ) * 0.5f;
                cam.transform.position = new Vector3(camX, 50f, camZ);
                cam.transform.rotation = Quaternion.Euler(90f, 0f, 0f); // straight down
                cam.nearClipPlane = 0.1f;
                cam.farClipPlane = 100f;
                cam.targetTexture = rt; // aspect is derived from the texture automatically

                cam.Render();

                RenderTexture.active = rt;
                snapshot = new Texture2D(rtWidth, rtHeight, TextureFormat.ARGB32, false);
                snapshot.ReadPixels(new Rect(0, 0, rtWidth, rtHeight), 0, 0);
                snapshot.Apply();

                byte[] png = snapshot.EncodeToPNG();
                File.WriteAllBytes(thumbnailAssetPath, png);
            }
            finally
            {
                authGO.SetActive(wasActive);
                RenderTexture.active = prevActive;
                if (camGO != null) UnityEngine.Object.DestroyImmediate(camGO);
                if (rt != null) { rt.Release(); UnityEngine.Object.DestroyImmediate(rt); }
                if (snapshot != null) UnityEngine.Object.DestroyImmediate(snapshot);
            }

            // Import as Sprite.
            AssetDatabase.ImportAsset(thumbnailAssetPath, ImportAssetOptions.ForceSynchronousImport);
            var importer = AssetImporter.GetAtPath(thumbnailAssetPath) as TextureImporter;
            if (importer != null)
            {
                importer.textureType = TextureImporterType.Sprite;
                importer.spriteImportMode = SpriteImportMode.Single;
                importer.SaveAndReimport();
            }
            return true;
        }

        // -------------------------------------------------------------------
        // PHASE 7 — Commit
        // -------------------------------------------------------------------

        private static void Phase7_Commit(BakeContext ctx, BakeReport report)
        {
            var target = ctx.Authoring.targetAsset;
            var src = ctx.AssembledData;

            // Field-by-field copy onto the target asset (preserves GUID).
            target.MapName = src.MapName;
            target.PlayerCount = src.PlayerCount;
            target.MapDescription = src.MapDescription;
            target.Author = src.Author;
            target.ScenePath = src.ScenePath;
            target.AuthoringHash = src.AuthoringHash;
            target.LastBakeTimestamp = src.LastBakeTimestamp;
            target.LastBakeOutcome = src.LastBakeOutcome;
            target.LastBakeWarningCount = src.LastBakeWarningCount;
            target.GridOriginTile = src.GridOriginTile;
            target.GridSize = src.GridSize;
            target.PlacementGrid = src.PlacementGrid;
            target.WalkabilityGrid = src.WalkabilityGrid;
            target.OwnerGrid = src.OwnerGrid;
            target.MapAreaGrid = src.MapAreaGrid;
            target.PlayerZones = src.PlayerZones;
            target.Goals = src.Goals;

            // Wire up the thumbnail sprite reference if a thumbnail was rendered.
            if (!string.IsNullOrEmpty(ctx.ThumbnailPath))
            {
                target.MapThumbnail = AssetDatabase.LoadAssetAtPath<Sprite>(ctx.ThumbnailPath);
            }

            EditorUtility.SetDirty(target);
            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();

            // Discard the in-memory ScriptableObject we built.
            UnityEngine.Object.DestroyImmediate(src);
        }
    }

    // -------------------------------------------------------------------
    // Internal context passed between phases. Lives only for the duration of one bake run.
    // -------------------------------------------------------------------

    internal class BakeContext
    {
        public LevelAuthoring Authoring;

        // Phase 1 outputs
        public List<VolumeBase> AllVolumes;
        public List<PlayerZoneVolume> PlayerZoneVolumes;
        public List<SpawnerVolume> SpawnerVolumes;
        public List<LeakExitVolume> LeakExitVolumes;
        public List<GoalVolume> GoalVolumes;
        public List<MapAreaVolume> MapAreaVolumes;

        // Phase 2 outputs
        public HashSet<PlayerSlot> ExpectedOwners;
        public HashSet<PlayerSlot> DeclaredOwners;

        // Phase 3 outputs
        public Dictionary<VolumeBase, HashSet<Vector2Int>> PerVolumeTiles;
        public Dictionary<PlayerSlot, HashSet<Vector2Int>> PerOwnerZoneTiles;
        public List<HashSet<Vector2Int>> PerGoalTiles;
        public HashSet<Vector2Int> MapAreaTiles;
        public Vector2Int MapMinTile;
        public Vector2Int MapMaxTile;

        // Phase 4 outputs
        public Vector2Int GridOriginTile;
        public Vector2Int GridSize;
        public PlacementState[,] PlacementGrid2D;
        public bool[,] WalkabilityGrid2D;
        public bool[,] MapAreaGrid2D;

        // Phase 5 outputs
        public HashSet<PlayerSlot> GoalAdjacentZones;

        // Phase 6 outputs
        public LevelData AssembledData;
        public string ThumbnailPath;
    }
}