using System;
using System.Collections;
using System.Collections.Generic;
using BlockOutReplica.Domain;
using BlockOutReplica.Infrastructure;
using BlockOutReplica.Presentation;
using UnityEngine;

namespace BlockOutReplica.Gameplay
{
    public enum BlockOutScreenState
    {
        Playing,
        LevelComplete,
        Home,
        Failed
    }

    [DisallowMultipleComponent]
    public sealed partial class BlockOutGameController : MonoBehaviour
    {
        private readonly List<BlockPieceView> pieces = new List<BlockPieceView>();
        private readonly List<DoorView> doors = new List<DoorView>();
        private readonly List<GameObject> generated = new List<GameObject>();
        private BlockOutProgress progress;
        private LevelDefinition level;
        private BlockOutMovementRules movementRules;
        private BlockPieceView draggingPiece;
        private Vector3 dragOffset;
        private Vector3 dragLeaderPosition;
        private Vector3 previousPointerBoardPosition;
        private bool hasPreviousPointerPosition;
        private bool timerRunning;
        private Camera gameCamera;
        private int activeExits;
        private Transform boardRoot;
        // Durations are provisional: original configuration values were not recovered.
        private const float SnapToDoorDuration = .10f;
        private const float MoveThroughDoorDuration = .36f;

        public float TimeLeft { get; private set; }
        public bool InputLocked { get; private set; }
        public bool IsPaused { get; private set; }
        public bool ShowTutorial => ScreenState == BlockOutScreenState.Playing &&
            progress != null && progress.LevelNumber == 1 && !timerRunning && pieces.Count > 0;
        public bool IsDragging => draggingPiece != null;
        public bool IsInputReviewRunning { get; private set; }
        public string Status { get; private set; }
        public string CurrentLevelId => progress == null ? "t140-level-1" : progress.CurrentLevelId;
        public int LevelNumber => progress == null ? 1 : progress.LevelNumber;
        public int CompletedLevels => progress == null ? 0 : progress.CompletedLevels;
        public int ObjectiveProgress => Journey.NodeProgress(CompletedLevels);
        public int ObjectiveTarget => Journey.NodeTarget(CompletedLevels);
        public bool IsTutorialChapter => progress != null && progress.IsTutorialChapter;
        public BlockOutScreenState ScreenState { get; private set; }

        private void Awake()
        {
            ConfigureCamera(out gameCamera);
            gameObject.AddComponent<BlockOutInputController>().Initialize(this, gameCamera);
            gameObject.AddComponent<BlockOutHud>().Initialize(this);
            progress = new BlockOutProgress(OriginalFlowRepository.Load());
            InitializeInteractions();
            ResetLevel();
            if (progress.CatalogCompleted || progress.ShouldStartAtHome) GoHome();
        }

        private void Update()
        {
            FitCameraToPortrait(gameCamera);
            if (Input.GetKeyDown(KeyCode.RightArrow)) LoadNextLevel();
            if (Input.GetKeyDown(KeyCode.LeftArrow)) LoadPreviousLevel();
#if UNITY_EDITOR
            if (Input.GetKeyDown(KeyCode.F8) && ScreenState == BlockOutScreenState.Playing)
                StartCoroutine(ReviewDragFirstPiece());
            if (Input.GetKeyDown(KeyCode.F9) && ScreenState == BlockOutScreenState.Playing)
                CompleteLevelForReview();
            if (Input.GetKeyDown(KeyCode.F10)) ResetProgressForReview();
#endif
            if (Input.GetKeyDown(KeyCode.Escape))
            { if (Modal != GameModal.None) CloseModal(); else if (SelectedBooster != BoosterType.None) CancelBoosterSelection(); else RequestPause(); }
            AdvanceClock(Time.deltaTime);
        }

        private void OnEnable()
        {
#if UNITY_EDITOR
            // Rebuild transient rules after hot reload; board ownership is retained
            // by the named root, so the previous board is removed before rebuilding.
            if (Application.isPlaying && gameCamera != null && movementRules == null)
            {
                bool wasHome = ScreenState == BlockOutScreenState.Home;
                InitializeInteractions(); ResetLevel();
                if (wasHome || progress.CatalogCompleted) GoHome();
            }
#endif
        }

        public void ResetLevel()
        {
            LoadCurrentLevel();
        }

        public void LoadNextLevel() => LoadAdjacentLevel(1);
        public void LoadPreviousLevel() => LoadAdjacentLevel(-1);

        public void PlayFromHome()
        {
            RequestEnterLevel();
        }

        public void ResetProgressForReview()
        {
            EnsureProgress();
            progress.ResetCurrentRun();
            LoadCurrentLevel();
        }

        private void LoadAdjacentLevel(int direction)
        {
            EnsureProgress();
            progress.MoveBy(direction);
            LoadCurrentLevel();
        }

        private void LoadCurrentLevel(string reviewLevelId = null)
        {
            EnsureProgress();
            StopAllCoroutines();
            var pointer=GetComponent<BlockOutInputController>();
            if(pointer!=null)pointer.Initialize(this,gameCamera);
            ClearGenerated();
            pieces.Clear(); doors.Clear(); draggingPiece = null;
            timerRunning = false; InputLocked = false; activeExits = 0;
            IsInputReviewRunning = false;
            IsPaused = false;
            ResetRunInteractions();
            ScreenState = BlockOutScreenState.Playing;
            Status = "拖动积木，从同色出口移出";
            string loadedLevelId = reviewLevelId ?? CurrentLevelId;
            TimeLeft = OriginalLevelSettings.Find(loadedLevelId)?.levelDuration ?? 180;
            if (gameCamera != null && gameCamera.GetComponent<AudioListener>() == null)
                gameCamera.gameObject.AddComponent<AudioListener>();
            level = OriginalLevelRepository.Load(loadedLevelId);
            movementRules = new BlockOutMovementRules(level, SpecialCanUseDoor);
            LevelViewFactory factory = new LevelViewFactory(GetBoardRoot(),
                Resources.Load<Material>("BlockColor"), generated);
            CreateBackgroundGlow(); CreateLight(); factory.BuildBoard(level);
            for (int i = 0; i < level.Doors.Count; i++)
                doors.Add(factory.CreateDoor(level, level.Doors[i], i));
            for (int i = 0; i < level.Pieces.Count; i++) pieces.Add(factory.CreatePiece(level, level.Pieces[i], i));
            SpecialPrepareLevel();
            Debug.Log($"BLOCKOUT_LEVEL_READY: id={loadedLevelId}, pieces={pieces.Count}, doors={level.Doors.Count}, cells={level.Cells.Count}, walls={level.Walls.Count}");
        }

        private void EnsureProgress()
        {
            if (progress == null)
                progress = new BlockOutProgress(OriginalFlowRepository.Load());
        }

        public void BeginDrag(Vector2 screenPosition, Camera camera)
        {
            if (InputLocked || IsPaused || Modal != GameModal.None || ScreenState != BlockOutScreenState.Playing || TimeLeft <= 0f) return;
            // Keep the top controls and bottom booster tray from leaking clicks
            // through to world-space pieces behind the IMGUI layer.
            if (screenPosition.y > Screen.height * .82f || screenPosition.y < Screen.height * .13f) return;
            if (!TryScreenToBoard(screenPosition, camera, out Vector3 point)) return;
            BlockPieceView piece = FindSelectablePiece(screenPosition, point, camera);
            if (piece == null || !pieces.Contains(piece)) return;
            if (SelectedBooster != BoosterType.None) { ApplyBoosterTarget(piece); return; }
            if (!SpecialCanMove(piece)) return;
            draggingPiece = piece; timerRunning = true; Status = "";
            dragOffset = piece.transform.position - point;
            dragLeaderPosition = piece.transform.position;
            previousPointerBoardPosition = point;
            hasPreviousPointerPosition = true;
            piece.SetDragging(true);
            SetDoorHighlight(piece.ColorId, true);
        }

        public void ContinueDrag(Vector2 screenPosition, Camera camera)
        {
            if (IsPaused || draggingPiece == null || !TryScreenToBoard(screenPosition, camera, out Vector3 point)) return;
            Vector3 current = draggingPiece.transform.position;
            Vector3 rawDesired = point + dragOffset; rawDesired.y = current.y;
            // The package config uses BlockSpeed=1000, so following is effectively
            // immediate; limiting the per-frame distance only prevents tunnelling.
            float dt = Mathf.Max(Time.deltaTime, .001f);
            dragLeaderPosition = Vector3.MoveTowards(dragLeaderPosition, rawDesired, 1000f * dt);
            Vector3 desired = dragLeaderPosition;
            Vector3 pointerDelta = hasPreviousPointerPosition ? point - previousPointerBoardPosition : Vector3.zero;
            previousPointerBoardPosition = point;
            hasPreviousPointerPosition = true;

            Vector3 resolved = ResolveDragPosition(current, desired, pointerDelta);
            DoorExitPlan plan = default;
            bool enteringDoor = false;
            // A fast swipe can cross the entire doorway in one input frame.
            // Commit at the first capture point so the exit animation still has a visible path.
            int captureSteps = Mathf.Max(1, Mathf.CeilToInt(Vector3.Distance(current, resolved) / .08f));
            for (int step = 1; step <= captureSteps; step++)
            {
                Vector3 sample = Vector3.Lerp(current, resolved, step / (float)captureSteps);
                if (!movementRules.TryPlanDoorExit(draggingPiece, sample, pieces,
                    pointerDelta, false, out plan)) continue;
                if (!movementRules.IsPathClear(draggingPiece, current, sample, pieces)) continue;
                resolved = sample;
                enteringDoor = true;
                break;
            }
            if (!enteringDoor && (resolved - desired).sqrMagnitude > .001f)
                draggingPiece.PlayBlocked(desired - resolved);
            Vector3 delta = resolved - draggingPiece.transform.position;
            draggingPiece.transform.position = resolved;
            draggingPiece.SetDragMotion(delta / Mathf.Max(Time.deltaTime, .016f));

            if (enteringDoor) StartPieceExit(draggingPiece, plan);
        }

        private Vector3 ResolveDragPosition(Vector3 current, Vector3 desired, Vector3 rawDelta)
        {
            Vector3 direct = ResolveSegment(current, desired);
            if ((direct - desired).sqrMagnitude < .0001f) return direct;

            Vector3 xFirst = current;
            xFirst.x = ResolveAllowedAxis(xFirst, desired.x, true);
            xFirst.z = ResolveAllowedAxis(xFirst, desired.z, false);
            Vector3 zFirst = current;
            zFirst.z = ResolveAllowedAxis(zFirst, desired.z, false);
            zFirst.x = ResolveAllowedAxis(zFirst, desired.x, true);

            float xError = (xFirst - desired).sqrMagnitude;
            float zError = (zFirst - desired).sqrMagnitude;
            if (Mathf.Abs(xError - zError) > .0001f) return xError < zError ? xFirst : zFirst;
            return Mathf.Abs(rawDelta.x) >= Mathf.Abs(rawDelta.z) ? xFirst : zFirst;
        }

        private Vector3 ResolveSegment(Vector3 start, Vector3 target)
        {
            float distance = Vector3.Distance(start, target);
            int steps = Mathf.Clamp(Mathf.CeilToInt(distance / .12f), 1, 48);
            Vector3 allowed = start;
            for (int i = 1; i <= steps; i++)
            {
                Vector3 candidate = Vector3.Lerp(start, target, i / (float)steps);
                if (!movementRules.IsAllowed(draggingPiece, candidate, pieces)) break;
                allowed = candidate;
            }
            return allowed;
        }

        private float ResolveAllowedAxis(Vector3 current, float target, bool horizontal)
        {
            float allowed = horizontal ? current.x : current.z;
            int steps = Mathf.Max(1, Mathf.CeilToInt(Mathf.Abs(target - allowed) / .12f));
            for (int step = 1; step <= steps; step++)
            {
                float next = Mathf.Lerp(horizontal ? current.x : current.z, target, step / (float)steps);
                Vector3 candidate = current;
                if (horizontal) candidate.x = next; else candidate.z = next;
                if (movementRules.IsAllowed(draggingPiece, candidate, pieces)) { allowed = next; continue; }
                float blocked = next;
                for (int i = 0; i < 10; i++)
                {
                    float middle = (allowed + blocked) * .5f;
                    candidate = current;
                    if (horizontal) candidate.x = middle; else candidate.z = middle;
                    if (movementRules.IsAllowed(draggingPiece, candidate, pieces)) allowed = middle;
                    else blocked = middle;
                }
                break;
            }
            return allowed;
        }

        public void EndDrag()
        {
            if (draggingPiece == null) return;
            BlockPieceView piece = draggingPiece; draggingPiece = null;
            hasPreviousPointerPosition = false;
            piece.SetDragging(false);
            SetDoorHighlight(piece.ColorId, false);
            if (movementRules.TryPlanDoorExit(piece, piece.transform.position, pieces,
                Vector3.zero, true, out DoorExitPlan plan))
            {
                StartPieceExit(piece, plan);
                return;
            }
            Vector3 sitTarget = movementRules.FindNearestLegalSit(piece, piece.transform.position, pieces);
            StartCoroutine(SitPiece(piece, sitTarget, .13f));
        }

        private void StartPieceExit(BlockPieceView piece, DoorExitPlan plan)
        {
            if (piece == null || !pieces.Contains(piece)) return;
            if (draggingPiece == piece) draggingPiece = null;
            hasPreviousPointerPosition = false;
            piece.SetDragging(false);
            SetDoorHighlight(piece.ColorId, false);
            SpecialBeginRemoval(piece, false, plan.SnapPosition);
            pieces.Remove(piece);
            activeExits++;
            piece.BeginDoorExit(plan);
            StartCoroutine(ExitPiece(piece, plan));
        }

        private IEnumerator SitPiece(BlockPieceView piece, Vector3 target, float duration)
        {
            InputLocked = true;
            Vector3 start = piece.transform.position;
            for (float elapsed = 0f; elapsed < duration; elapsed += Time.deltaTime)
            {
                float t = Mathf.Clamp01(elapsed / duration);
                float eased = 1f - Mathf.Pow(1f - t, 3f);
                piece.transform.position = Vector3.LerpUnclamped(start, target, eased);
                yield return null;
            }
            piece.transform.position = target;
            InputLocked = false;
            // A release can miss lateral capture, then settle exactly into the mouth.
            // Recheck the settled pose and its complete unobstructed exit path.
            if (movementRules.TryPlanDoorExit(piece, target, pieces,
                Vector3.zero, true, out DoorExitPlan plan))
                StartPieceExit(piece, plan);
            else piece.PlaySnap();
        }

        private BlockPieceView FindSelectablePiece(Vector2 screenPosition, Vector3 boardPoint, Camera camera)
        {
            Ray ray = camera.ScreenPointToRay(screenPosition);
            if (Physics.Raycast(ray, out RaycastHit hit, 100f))
            {
                BlockPieceView direct = hit.collider.GetComponentInParent<BlockPieceView>();
                if (direct != null) return direct;
            }

            const float searchRadius = .8f;
            BlockPieceView nearest = null;
            float nearestDistance = searchRadius * searchRadius;
            for (int i = 0; i < pieces.Count; i++)
            {
                BlockPieceView candidate = pieces[i];
                Collider collider = candidate.GetComponent<Collider>();
                if (collider == null) continue;
                Vector3 probe = new Vector3(boardPoint.x, candidate.transform.position.y, boardPoint.z);
                Vector3 closest = collider.ClosestPoint(probe);
                float distance = (new Vector2(closest.x, closest.z) -
                    new Vector2(boardPoint.x, boardPoint.z)).sqrMagnitude;
                if (distance > nearestDistance) continue;
                nearestDistance = distance;
                nearest = candidate;
            }
            return nearest;
        }

        public void TogglePause()
        {
            RequestPause();
        }

        private IEnumerator ExitPiece(BlockPieceView piece, DoorExitPlan plan)
        {
            Vector3 start = piece.transform.position;
            for (float elapsed = 0f; elapsed < SnapToDoorDuration; elapsed += Time.deltaTime)
            {
                if (IsPaused) { yield return null; elapsed -= Time.deltaTime; continue; }
                float t = Mathf.Clamp01(elapsed / SnapToDoorDuration);
                piece.transform.position = Vector3.Lerp(start, plan.SnapPosition, 1f - Mathf.Pow(1f - t, 3f));
                yield return null;
            }
            piece.transform.position = plan.SnapPosition;
            DoorView door = plan.DoorIndex < doors.Count ? doors[plan.DoorIndex] : null;
            if (door != null) door.PlayAccept(plan,piece);
            for (float elapsed = 0f; elapsed < MoveThroughDoorDuration; elapsed += Time.deltaTime)
            {
                if (IsPaused) { yield return null; elapsed -= Time.deltaTime; continue; }
                float t = Mathf.Clamp01(elapsed / MoveThroughDoorDuration);
                float eased = t * t * (3f - 2f * t);
                piece.transform.position = Vector3.Lerp(plan.SnapPosition, plan.ClearPosition, eased);
                piece.SetExitProgress(t);
                yield return null;
            }
            piece.transform.position = plan.ClearPosition;
            SpecialCompleteRemoval(piece);
            Destroy(piece.gameObject);
            activeExits--;
            CloseUnusedDoors();
            Status = pieces.Count == 0 ? "LEVEL COMPLETE!" : "出口正确";
            yield return FinishBoardIfCleared();
        }

        private void SpawnCompletionBurst()
        {
            for (int i = 0; i < 28; i++)
            {
                float angle = i * Mathf.PI * 2f / 28f + UnityEngine.Random.Range(-.12f, .12f);
                float speed = UnityEngine.Random.Range(2.4f, 4.8f);
                Vector3 velocity = new Vector3(Mathf.Cos(angle), UnityEngine.Random.Range(1.2f, 3.1f), Mathf.Sin(angle)) * speed;
                SpawnFx(Vector3.up * .45f, velocity, i % 3 == 0 ? 0 : (i % 3 == 1 ? 10 : 11), 1.15f);
            }
        }

        private void SetDoorHighlight(int colorId, bool value)
        {
            for (int i = 0; i < doors.Count; i++)
                if (doors[i] != null && doors[i].ColorId == colorId)
                    doors[i].SetHighlighted(value);
        }

        private void SpawnFx(Vector3 position, Vector3 velocity, int colorId, float lifetime)
        {
            GameObject item = GameObject.CreatePrimitive(PrimitiveType.Cube);
            item.name = "Block Motion Spark";
            item.transform.SetParent(GetBoardRoot());
            item.transform.position = position;
            item.transform.localScale = new Vector3(.10f, .055f, .16f) * UnityEngine.Random.Range(.7f, 1.25f);
            Destroy(item.GetComponent<Collider>());
            Renderer renderer = item.GetComponent<Renderer>();
            Material material = new Material(Shader.Find("Standard"));
            material.color = OriginalAssetCatalog.FallbackColor(colorId);
            if (material.HasProperty("_Glossiness")) material.SetFloat("_Glossiness", .82f);
            renderer.material = material;
            item.AddComponent<BlockFxParticle>().Initialize(velocity, lifetime, 4.8f);
            generated.Add(item);
        }

        private IEnumerator CompleteLevelFlow()
        {
            if (completionCommitted) yield break;
            completionCommitted = true; completionStarted = true;
            timerRunning = false;
            InputLocked = true;
            Modal = GameModal.None; SelectedBooster = BoosterType.None; SetPaused(false);
            ScreenState = BlockOutScreenState.LevelComplete;
            wonLevel = progress.LevelNumber;
            bool returnHome = progress.ShouldReturnHomeAfterWin;
            winReturnsHome = returnHome;
            bool advanced=progress.CompleteLevel();
            // Preserve source Regular20 per win. Original early-wallet timing may
            // be deferred; an unchanged intermediate screenshot did not prove 0.
            awardedReward = advanced ? economy.RegularLevelWinCoinReward : 0;
            Player.AwardCoins(awardedReward);
            if (advanced) Journey.QueueWinReward(CompletedLevels);
            PlayUiSound("win_screen");
            Debug.Log($"BLOCKOUT_LEVEL_COMPLETE: next={progress.LevelNumber}, returnHome={returnHome}");
            yield return new WaitForSecondsRealtime(returnHome ? 1.4f : .85f);
            if (ScreenState == BlockOutScreenState.LevelComplete) ContinueAfterWin();
        }

#if UNITY_EDITOR
        public void ReviewExitEffects()
        {
            LoadCurrentLevel("t140-level-4");
            IsInputReviewRunning = true;
            StartCoroutine(ReviewExitEffectsRoutine());
        }

        private IEnumerator ReviewExitEffectsRoutine()
        {
            yield return null;
            System.IO.Directory.CreateDirectory("Docs/iterations");
            // Clear the two real bottom blockers via their doors, not by deleting
            // obstacles or teleporting the long block through them.
            foreach (int color in new[] {11, 10})
            {
                BlockPieceView blocker = pieces.Find(p => p.ColorId == color && p.InitialBoardPosition.z < -2.4f);
                BeginDrag(gameCamera.WorldToScreenPoint(blocker.transform.position), gameCamera);
                EndDrag();
                yield return new WaitForSeconds(.6f);
            }
            BlockPieceView piece = pieces.Find(p => p.ColorId == 8);
            DoorView door = doors.Find(p => p.ColorId == 8);
            OriginalDoorExitEffect effect = door.RecoveredEffect;
            if (effect == null)
            {
                Debug.LogError("BLOCKOUT_EXIT_FX_RUNTIME: passed=False, recovered effect missing");
                ResetLevel(); yield break;
            }
            Transform panel = effect.transform.Find("DoorViewRoot/DoorRoot");
            Vector3 panelStart = panel.position;
            BeginDrag(gameCamera.WorldToScreenPoint(piece.transform.position), gameCamera);
            ContinueDrag(gameCamera.WorldToScreenPoint(piece.transform.position + Vector3.right * 2.3f), gameCamera);
            if (draggingPiece != null) EndDrag();
            int peak = 0, capture = 0;
            float motion = 0f, maxRotation = 0f, elapsed = 0f;
            bool paused = true;
            float[] captureTimes = {.16f, .34f, .56f, .84f};
            while (elapsed < 1.8f)
            {
                peak = Mathf.Max(peak, effect.LiveParticleCount);
                motion = Mathf.Max(motion, Vector3.Dot(panel.position - panelStart, Vector3.right));
                if (piece != null)
                    maxRotation = Mathf.Max(maxRotation, Quaternion.Angle(Quaternion.identity,
                        piece.transform.Find("Animated Visual Root").localRotation));
                if (capture < captureTimes.Length && elapsed >= captureTimes[capture])
                {
                    ScreenCapture.CaptureScreenshot($"Docs/iterations/2026-10-20-exit-fx-{capture}.png");
                    capture++;
                }
                if (elapsed > .27f && elapsed < .32f)
                {
                    TogglePause();
                    float before = effect.PlaybackTime;
                    int beforeCount = effect.LiveParticleCount;
                    for (int frame = 0; frame < 8; frame++) yield return null;
                    paused &= effect.PlaybackTime == before && effect.LiveParticleCount == beforeCount;
                    TogglePause();
                    elapsed = .32f;
                }
                elapsed += Time.deltaTime;
                yield return null;
            }
            bool passed = pieces.Count == 15 && activeExits == 0 && piece == null && peak > 0 &&
                motion > .15f && paused && maxRotation < .001f && !effect.IsPlaying && effect.LiveParticleCount == 0;
            string result = $"BLOCKOUT_EXIT_FX_RUNTIME: passed={passed}, remaining={pieces.Count}, peakParticles={peak}, outwardMotion={motion:F3}, pause={paused}, maxBlockRotation={maxRotation:F4}, tailCleared={!effect.IsPlaying && effect.LiveParticleCount == 0}";
            if (passed) Debug.Log(result); else Debug.LogError(result);
            IsInputReviewRunning = false;
            ResetLevel();
        }

        public void ReviewLevel4Regression()
        {
            LoadCurrentLevel("t140-level-4");
            IsInputReviewRunning = true;
            StartCoroutine(ReviewLevel4RegressionRoutine(false, true, false));
        }

        private IEnumerator ReviewLevel4RegressionRoutine(bool offsetTrial, bool visuals, bool aligned)
        {
            yield return null;
            foreach (BlockPieceView item in pieces)
                visuals &= item.GetComponentsInChildren<SpriteRenderer>().Length > 0 &&
                    OriginalAssetCatalog.LoadStud(item.ColorId) != null;
            System.IO.Directory.CreateDirectory("Docs/iterations");
            if (!offsetTrial) ScreenCapture.CaptureScreenshot("Docs/iterations/2026-10-19-level4-colors.png");
            yield return new WaitForEndOfFrame();
                // Free the bottom-left neighbour by taking its actual black door.
                BlockPieceView black = pieces.Find(p => p.ColorId == 11 &&
                    p.InitialBoardPosition.z < -2.4f);
                BeginDrag(gameCamera.WorldToScreenPoint(black.transform.position), gameCamera);
                bool selectedBlack = draggingPiece == black;
                EndDrag();
                yield return new WaitForSeconds(.65f);
                BlockPieceView white = pieces.Find(p => p.ColorId == 10 &&
                    p.InitialBoardPosition.z < -2.4f);
                BeginDrag(gameCamera.WorldToScreenPoint(white.transform.position), gameCamera);
                bool selectedWhite = draggingPiece == white;
                if (offsetTrial) white.transform.position += Vector3.left * .22f;
                bool legal = movementRules.IsAllowed(white, white.transform.position, pieces);
                EndDrag();
                yield return new WaitForSeconds(.85f);
                bool exited = selectedBlack && selectedWhite && legal && black == null && white == null &&
                    pieces.Count == 16 && activeExits == 0 && !InputLocked;
            if (!offsetTrial)
            {
                // Level reload stops all coroutines: start the second pass explicitly.
                LoadCurrentLevel("t140-level-4");
                IsInputReviewRunning = true;
                StartCoroutine(ReviewLevel4RegressionRoutine(true, visuals, exited));
                yield break;
            }
            bool settled = exited;
            bool passed = visuals && aligned && settled;
            string result = $"BLOCKOUT_LEVEL4_REGRESSION: passed={passed}, originalSprites={visuals}, alignedRelease={aligned}, offsetReleaseSettlesAndExits={settled}, remaining={pieces.Count}";
            if (passed) Debug.Log(result); else Debug.LogError(result);
            IsInputReviewRunning = false;
            ResetLevel();
        }

        public void ReviewDoorExitFlow()
        {
            // An isolated first-level board; saved player progression is not changed.
            LoadCurrentLevel("t140-level-1");
            IsInputReviewRunning = true;
            StartCoroutine(ReviewDoorExitFlowRoutine());
        }

        private IEnumerator ReviewDoorExitFlowRoutine()
        {
            yield return null;
            BlockPieceView piece = pieces[0];
            Vector3 start = piece.transform.position;
            Vector3 target = new Vector3(start.x, start.y, 1.55f);
            BeginDrag(gameCamera.WorldToScreenPoint(start), gameCamera);
            ContinueDrag(gameCamera.WorldToScreenPoint(target + Vector3.forward * 4f), gameCamera);
            yield return null;
            bool committed = activeExits == 1 && pieces.Count == 2 && draggingPiece == null;
            bool fastSwipeCaptured = piece != null && piece.transform.position.z < 1.65f;
            bool colliderDisabled = piece != null && !piece.GetComponent<Collider>().enabled;
            bool materialApplied = piece != null && piece.GetComponentInChildren<SpriteRenderer>()
                .sharedMaterial.shader.name == "BlockOut/ClippedSprite";
            bool canSelectOther = !InputLocked;
            if (committed)
            {
                BlockPieceView other = pieces[0];
                BeginDrag(gameCamera.WorldToScreenPoint(other.transform.position), gameCamera);
                canSelectOther &= draggingPiece == other;
                if (draggingPiece != null) EndDrag();
            }
            yield return new WaitForSeconds(.16f);
            System.IO.Directory.CreateDirectory("Docs/iterations");
            ScreenCapture.CaptureScreenshot("Docs/iterations/2026-10-19-exit-midpoint.png");
            float maximumRotation = 0f;
            for (int frames = 0; frames < 300 && piece != null; frames++)
            {
                Transform visual = piece.transform.Find("Animated Visual Root");
                maximumRotation = Mathf.Max(maximumRotation,
                    Quaternion.Angle(Quaternion.identity, visual.localRotation));
                yield return null;
            }
            bool passed = committed && fastSwipeCaptured && piece == null && colliderDisabled && materialApplied && canSelectOther &&
                pieces.Count == 2 && activeExits == 0 && maximumRotation < .001f;
            string result = $"BLOCKOUT_DOOR_RUNTIME_REVIEW: passed={passed}, committed={committed}, fastSwipeCaptured={fastSwipeCaptured}, colliderDisabled={colliderDisabled}, clipShader={materialApplied}, concurrentSelection={canSelectOther}, remaining={pieces.Count}, activeExits={activeExits}, maxRotation={maximumRotation:F4}";
            if (passed) Debug.Log(result); else Debug.LogError(result);
            IsInputReviewRunning = false;
            ResetLevel();
        }

        public void ReviewCollisionFeedback()
        {
            ResetLevel();
            IsInputReviewRunning = true;
            StartCoroutine(ReviewCollisionFeedbackRoutine());
        }

        private IEnumerator ReviewCollisionFeedbackRoutine()
        {
            yield return null;
            if (pieces.Count < 2 || InputLocked || IsDragging)
            { IsInputReviewRunning = false; yield break; }
            BlockPieceView piece = pieces[0];
            Vector3 start = piece.transform.position;
            Vector3 pointerTarget = pieces[1].transform.position;
            BeginDrag(gameCamera.WorldToScreenPoint(start), gameCamera);
            if (draggingPiece != piece)
            { IsInputReviewRunning = false; Debug.LogError("BLOCKOUT_COLLISION_REVIEW: selection failed"); yield break; }
            float maxRotation = 0f;
            bool valid = true;
            int frames = 0;
            for (; frames < 180 && draggingPiece == piece; frames++)
            {
                ContinueDrag(gameCamera.WorldToScreenPoint(pointerTarget), gameCamera);
                yield return new WaitForEndOfFrame();
                Transform visual = piece.transform.Find("Animated Visual Root");
                maxRotation = Mathf.Max(maxRotation, Quaternion.Angle(Quaternion.identity, visual.localRotation));
                valid &= movementRules.IsAllowed(piece, piece.transform.position, pieces);
            }
            Vector3 collisionPosition = piece.transform.position;
            EndDrag();
            yield return new WaitForSeconds(.2f);
            bool passed = valid && maxRotation < .001f && frames == 180 &&
                (collisionPosition - pointerTarget).sqrMagnitude > .01f;
            string message = $"BLOCKOUT_COLLISION_REVIEW: passed={passed}, frames={frames}, maxRotation={maxRotation:F4}, legal={valid}, start={start}, contact={collisionPosition}, sit={piece.transform.position}";
            if (passed) Debug.Log(message); else Debug.LogError(message);
            IsInputReviewRunning = false;
        }

        private IEnumerator ReviewDragFirstPiece()
        {
            if (pieces.Count == 0 || gameCamera == null) yield break;
            BlockPieceView piece = pieces[0];
            DoorDefinition door = null;
            for (int i = 0; i < level.Doors.Count; i++)
                if (level.Doors[i].ColorId == piece.ColorId) { door = level.Doors[i]; break; }
            if (door == null) yield break;

            Vector3 startWorld = piece.transform.position;
            Vector3 targetWorld = level.AverageWorld(door.Cells, .28f)
                + BlockOutMovementRules.DirectionFor(door.Side) * 2.2f;
            BeginDrag(gameCamera.WorldToScreenPoint(startWorld), gameCamera);
            for (int step = 1; step <= 36 && draggingPiece != null; step++)
            {
                Vector3 world = Vector3.Lerp(startWorld, targetWorld, step / 36f);
                ContinueDrag(gameCamera.WorldToScreenPoint(world), gameCamera);
                yield return null;
            }
            EndDrag();
        }

        private void CompleteLevelForReview()
        {
            StopAllCoroutines();
            for (int i = 0; i < pieces.Count; i++)
                if (pieces[i] != null) Destroy(pieces[i].gameObject);
            pieces.Clear();
            Status = "LEVEL COMPLETE!";
            StartCoroutine(CompleteLevelFlow());
        }
#endif

        private static bool TryScreenToBoard(Vector2 screenPosition, Camera camera, out Vector3 point)
        {
            Ray ray = camera.ScreenPointToRay(screenPosition);
            if (new Plane(Vector3.up, new Vector3(0f, .28f, 0f)).Raycast(ray, out float distance))
            { point = ray.GetPoint(distance); return true; }
            point = default; return false;
        }

        private static void ConfigureCamera(out Camera camera)
        {
            camera = Camera.main;
            if (camera == null)
            {
                GameObject cameraObject = new GameObject("Main Camera");
                cameraObject.tag = "MainCamera"; camera = cameraObject.AddComponent<Camera>();
            }
            camera.orthographic = true;
            camera.transform.position = new Vector3(0f, 10f, .15f);
            camera.transform.rotation = Quaternion.Euler(90f, 0f, 0f);
            camera.backgroundColor = new Color(.055f, .05f, .20f);
            camera.clearFlags = CameraClearFlags.SolidColor;
            FitCameraToPortrait(camera);
        }

        private static void FitCameraToPortrait(Camera camera)
        {
            if (camera == null) return;
            // Level 1 reference: the outer board occupies about 71% of the
            // 882-pixel game width. A 4.9-unit horizontal half-view reproduces it.
            camera.orthographicSize = Mathf.Max(5.8f, 4.45f / Mathf.Max(.01f, camera.aspect));
        }

        private void CreateLight()
        {
            GameObject item = new GameObject("Soft Light"); item.transform.SetParent(GetBoardRoot());
            Light light = item.AddComponent<Light>(); light.type = LightType.Directional;
            light.intensity = .92f; light.shadows = LightShadows.Soft;
            item.transform.rotation = Quaternion.Euler(45f, -30f, 0f); generated.Add(item);
        }

        private void CreateBackgroundGlow()
        {
            const int width = 64;
            const int height = 128;
            Texture2D texture = new Texture2D(width, height, TextureFormat.RGBA32, false);
            texture.name = "Runtime Background Glow";
            texture.wrapMode = TextureWrapMode.Clamp;
            texture.filterMode = FilterMode.Bilinear;
            Color edge = new Color(.095f, .085f, .205f, 1f);
            Color center = new Color(.19f, .165f, .39f, 1f);
            for (int y = 0; y < height; y++)
            for (int x = 0; x < width; x++)
            {
                float nx = (x / (width - 1f) - .5f) * 1.55f;
                float ny = (y / (height - 1f) - .52f) * .95f;
                float glow = Mathf.Clamp01(1f - Mathf.Sqrt(nx * nx + ny * ny));
                glow = Mathf.SmoothStep(0f, 1f, glow) * .86f;
                texture.SetPixel(x, y, Color.Lerp(edge, center, glow));
            }
            texture.Apply();
            Sprite sprite = Sprite.Create(texture, new Rect(0, 0, width, height),
                new Vector2(.5f, .5f), 32f);
            GameObject item = new GameObject("Background Glow");
            item.transform.SetParent(GetBoardRoot());
            item.transform.position = new Vector3(0f, -.72f, 0f);
            item.transform.rotation = Quaternion.Euler(90f, 0f, 0f);
            item.transform.localScale = new Vector3(12f / sprite.bounds.size.x,
                21f / sprite.bounds.size.y, 1f);
            SpriteRenderer renderer = item.AddComponent<SpriteRenderer>();
            renderer.sprite = sprite;
            renderer.sortingOrder = -100;
            generated.Add(item);
        }

        private void ClearGenerated()
        {
            // A named ownership root survives script hot reload, unlike readonly
            // runtime lists. Deactivate immediately so old colliders cannot overlap
            // the board loaded in this same frame.
            var roots = new List<GameObject>();
            foreach (Transform child in transform)
                if (child.name == "Generated Board") roots.Add(child.gameObject);
            foreach (GameObject item in roots) { item.SetActive(false); Destroy(item); }
            boardRoot = null;
            for (int i = 0; i < generated.Count; i++) if (generated[i] != null) Destroy(generated[i]);
            generated.Clear();
        }

        private Transform GetBoardRoot()
        {
            if (boardRoot == null)
            { boardRoot = new GameObject("Generated Board").transform; boardRoot.SetParent(transform, false); }
            return boardRoot;
        }
    }
}