using System;
using System.Collections.Generic;
using System.Reflection;
using UnityEditor;
using UnityEngine;

using UnityTcp.Editor.Helpers;

namespace UnityTcp.Editor.Native
{
    internal static partial class NativeWindowBridgeHost
    {
        private const string kCompositeSlotMappingKey = "NWB_CompositeSlotMapping";
        private const string kCompositePrePlayTabKey = "NWB_CompositePrePlayTab";
        private const string kCompositeRestoreJsonKey = "NWB_CompositeRestoreJson";
        private const string kCompositeRestoreFpsKey = "NWB_CompositeRestoreFps";
        private const string kDefaultCompositeLayoutPreset = "unity-default-layout";
        private const string kSavedCompositeLayoutPreset = "codely-saved-layout";

        // Saved when StartCompositeOffscreenCapture succeeds so domain reload
        // can auto-resume without waiting for the browser to re-send the layout.
        private static string s_LastCompositeRequestJson;

        private enum CompositeLayoutApplyMode
        {
            Auto = 0,
            AppendSingle = 1,
            StrictReplace = 2,
            PreserveExisting = 3,
            ReplaceManagedKeepNative = 4
        }

        [Serializable]
        private sealed class CompositeStreamRequest
        {
            public int fps = 30;
            public int width;
            public int height;
            public string layoutPreset;
            public string applyMode;
            public string focusedSlotId;
            public CompositeSlotRequest[] slots;
        }

        [Serializable]
        private sealed class CompositeSlotRequest
        {
            public string slotId;
            public string windowType;
            public string title;
            public CompositeRect rect;
        }

        [Serializable]
        private sealed class CompositeRect
        {
            public float x;
            public float y;
            public float w;
            public float h;
        }

        [Serializable]
        private sealed class CompositeSlotMappingEntry
        {
            public string slotId;
            public long instanceId;
            public string windowType;
            public CompositeRect rect;
        }

        [Serializable]
        private sealed class CompositeSlotMappingStore
        {
            public CompositeSlotMappingEntry[] entries;
        }

        private sealed class CompositeCaptureSlot
        {
            public string SlotId;
            public string WindowTypeName;
            public EditorWindow Window;
            public System.Type WindowType;
            public RenderTexture SourceRT;
            public Rect NormalizedRect;
            public bool OwnsWindow;
            public bool CloseWindowOnRelease;
#if UNITY_EDITOR_WIN
            // Win32 HWNDs for keyboard injection (SetFocus + PostMessageW).
            // Detected after Show() using the before/after HWND diff technique.
            public IntPtr ContainerHwnd;
            public IntPtr GUIViewHwnd;
#endif
#if UNITY_EDITOR_OSX
            // NSWindow pointer for keyboard injection (activateIgnoringOtherApps + makeKeyWindow).
            public IntPtr NSWindow;
#endif
        }

        private sealed class CompositeLayoutNode
        {
            public CompositeSlotRequest Slot;
            public CompositeLayoutNode First;
            public CompositeLayoutNode Second;
            public string Edge;
        }

        private sealed class CompositeLayoutOperation
        {
            public string Preset;
            public string HierarchySlotId;
            public string GameSlotId;
            public string SceneSlotId;
            public string ProjectSlotId;
            public string ConsoleSlotId;
            public string InspectorSlotId;
            public int Step;
            public int WaitFrames;
            public int Attempts;
        }

        private static bool s_CompositeActive;
        private static readonly Dictionary<string, CompositeCaptureSlot> s_CompositeSlots =
            new Dictionary<string, CompositeCaptureSlot>();
        private static RenderTexture s_CompositeRT;
        private static RenderTexture s_CompositePaneDragRT;
        private static Texture2D s_CompositeReadbackTex;
        private static int s_CompositeLogicalWidth;
        private static int s_CompositeLogicalHeight;
        private static Rect s_CompositeFrameBoundsLogical = Rect.zero;
        private static Vector2 s_CompositeFrameOffsetPixels = Vector2.zero;
        private static Vector2 s_CompositeFrameScalePixels = Vector2.one;
        private static bool s_CompositeWorkspaceReflowPending;
#pragma warning disable CS0414
        private static int s_CompositeLastViewCount;
#pragma warning restore CS0414
        private static int s_CompositeSkipFrames;
        private static CompositeLayoutOperation s_CompositeLayoutOperation;
#pragma warning disable CS0414
        private static bool s_CompositePlayModeInitDone;
        private static int s_CompositeForceRepaintFrames;
#pragma warning restore CS0414
        private static object s_CompositeMouseCaptureView;
        private static CompositeCaptureSlot s_CompositeMouseCaptureSlot;
        private static EditorWindow s_CompositeLastTabTarget;

        /// <summary>
        /// Save composite slot mappings so surviving windows can be rediscovered
        /// after domain reload without closing them.
        /// </summary>
        private static void SaveCompositeSlotMapping()
        {
            if (s_CompositeSlots == null || s_CompositeSlots.Count == 0)
            {
                SessionState.EraseString(kCompositeSlotMappingKey);
                return;
            }

            var entries = new List<CompositeSlotMappingEntry>();
            foreach (var kvp in s_CompositeSlots)
            {
                var slot = kvp.Value;
                if (slot?.Window == null) continue;
                entries.Add(new CompositeSlotMappingEntry
                {
                    slotId = kvp.Key,
                    instanceId = slot.Window.GetStableInstanceId(),
                    windowType = slot.WindowTypeName ?? string.Empty,
                    rect = new CompositeRect
                    {
                        x = slot.NormalizedRect.x,
                        y = slot.NormalizedRect.y,
                        w = slot.NormalizedRect.width,
                        h = slot.NormalizedRect.height
                    }
                });
            }
            if (entries.Count == 0)
            {
                SessionState.EraseString(kCompositeSlotMappingKey);
                return;
            }

            string json = JsonUtility.ToJson(new CompositeSlotMappingStore { entries = entries.ToArray() });
            SessionState.SetString(kCompositeSlotMappingKey, json);
            LogVerbose($"[NWB-Composite] Saved slot mapping ({entries.Count} slots) before reload");
        }

        /// <summary>
        /// After domain reload, rediscover surviving EditorWindows from the
        /// saved mapping and pre-populate s_CompositeSlots.
        /// </summary>
        private static void PrePopulateCompositeSlots()
        {
            string json = SessionState.GetString(kCompositeSlotMappingKey, "");
            SessionState.EraseString(kCompositeSlotMappingKey);
            if (string.IsNullOrEmpty(json))
                return;

            CompositeSlotMappingStore store = null;
            try
            {
                store = JsonUtility.FromJson<CompositeSlotMappingStore>(json);
            }
            catch (Exception ex)
            {
                CodelyLogger.LogWarning($"[NWB-Composite] Failed to parse slot mapping: {ex.Message}");
                return;
            }
            if (store?.entries == null || store.entries.Length == 0)
                return;

            int restored = 0;
            foreach (var entry in store.entries)
            {
                if (entry == null) continue;
                string slotId = entry.slotId;
                string typeName = entry.windowType;
                long instanceId = entry.instanceId;
                if (string.IsNullOrEmpty(slotId) || instanceId == 0)
                    continue;

                var obj = InstanceIdExtensions.InstanceIdToObject(instanceId);
                var window = obj as EditorWindow;
                if (window == null)
                {
                    LogVerbose($"[NWB-Composite] Slot '{slotId}' window id={instanceId} did not survive reload");
                    continue;
                }

                var slot = new CompositeCaptureSlot
                {
                    SlotId = slotId,
                    WindowTypeName = typeName,
                    WindowType = window.GetType(),
                    Window = window,
                    NormalizedRect = ToUnityRect(entry.rect),
                    OwnsWindow = true,
                    CloseWindowOnRelease = false
                };
                s_CompositeSlots[slotId] = slot;
                restored++;
            }
            if (restored > 0)
                LogVerbose($"[NWB-Composite] Pre-populated {restored} slots from surviving windows");
        }

        private static Rect ToUnityRect(CompositeRect rect)
        {
            if (rect == null)
                return new Rect(0f, 0f, 1f, 1f);
            return new Rect(
                rect.x,
                rect.y,
                Mathf.Max(0.01f, rect.w),
                Mathf.Max(0.01f, rect.h));
        }

        /// <summary>
        /// Find an existing DockArea from already-created composite slots.
        /// Used by CreateCompositeSlot to dock new views immediately.
        /// </summary>
        private static object FindExistingCompositeDockArea()
        {
            foreach (CompositeCaptureSlot slot in s_CompositeSlots.Values)
            {
                if (slot?.Window == null) continue;
                object view = GetParentView(slot.Window);
                if (view != null && view.GetType().Name == "DockArea")
                    return view;
            }
            return null;
        }

        private static bool StartCompositeOffscreenCapture(string requestJson, int fps, int width, int height,
            bool nativeAlreadyStarted = false,
            CompositeLayoutApplyMode applyMode = CompositeLayoutApplyMode.Auto)
        {
#if UNITY_EDITOR_WIN || UNITY_EDITOR_OSX
            if (!IsAvailable()) return false;

            try
            {
                CompositeStreamRequest request = JsonUtility.FromJson<CompositeStreamRequest>(requestJson);
                if (request == null || request.slots == null || request.slots.Length == 0)
                {
                    CodelyLogger.LogError("[NWB-Composite] Empty composite layout request");
                    return false;
                }

                int logicalW = Mathf.Max((width > 0 ? width : request.width), 320);
                int logicalH = Mathf.Max((height > 0 ? height : request.height), 240);
                fps = Mathf.Max(1, fps > 0 ? fps : request.fps);
                CompositeLayoutApplyMode resolvedApplyMode = ResolveCompositeLayoutApplyMode(request, applyMode);
                bool samePresetDetachedReconnect = ShouldPreserveCompositeLayoutForSamePreset(request);
                if (samePresetDetachedReconnect)
                {
                    bool canKeepPreserve = TryNormalizeSlotIdsForPresetReuse(request) &&
                                           TryEnsurePresetLayoutConsistencyWithoutRebuild(request);
                    if (canKeepPreserve)
                    {
                        resolvedApplyMode = CompositeLayoutApplyMode.PreserveExisting;
                        LogVerbose($"[NWB-Composite] Same preset detached reconnect, preserve existing layout: preset={request.layoutPreset} slots={s_CompositeSlots.Count}");
                    }
                    else
                    {
                        // Rect consistency check failed and in-place tree convergence
                        // could not be completed. Fall back to normal request-driven
                        // rebuild path (strict/replace modes) for recovery.
                        samePresetDetachedReconnect = false;
                        resolvedApplyMode = ResolveCompositeLayoutApplyMode(request, applyMode);
                        LogVerbose($"[NWB-Composite] Same preset detached reconnect fallback to rebuild: preset={request.layoutPreset} mode={resolvedApplyMode}");
                    }
                }
                LogVerbose($"[NWB-Composite] Apply mode: {resolvedApplyMode}, requested slots={request.slots.Length}, current slots={s_CompositeSlots.Count}, focusedSlotId={request.focusedSlotId}");

                // Switch cleanly from single-window offscreen to composite mode.
                if (s_OffscreenActive && !s_CompositeActive && s_OffscreenTarget != null)
                {
                    if (s_OffscreenAutoFloatingWindow)
                    {
                        try { s_OffscreenTarget.Close(); }
                        catch (Exception ex) { CodelyLogger.LogWarning($"[NWB-Composite] Close old single target failed: {ex.Message}"); }
                    }
                    s_OffscreenTarget = null;
                    s_OffscreenTargetType = null;
                    s_OffscreenAutoFloatingWindow = false;
                    s_OffscreenFloatingWindowInstanceId = 0;
                }

                EnsureCompositeRenderTargets(logicalW, logicalH);

                // Close existing docked GameView(s) BEFORE ApplyCompositeLayout creates
                // the floating slot windows. The docked GameView's size info
                // (PanelSettings.GetGameViewResolution) interferes with the floating
                // GameView's PanelSettings.m_TargetRect if still present during Show().
                // Skip in PreserveExisting mode (domain reload resume) — the floating
                // GameView already survived the reload.
                if (!s_ClosedDockedGameViewForStreaming && resolvedApplyMode != CompositeLayoutApplyMode.PreserveExisting)
                {
                    bool hasGameViewSlot = false;
                    if (request.slots != null)
                    {
                        foreach (var slotReq in request.slots)
                        {
                            if (slotReq != null && !string.IsNullOrEmpty(slotReq.windowType)
                                && slotReq.windowType.Contains("GameView"))
                            {
                                hasGameViewSlot = true;
                                break;
                            }
                        }
                    }
                    if (hasGameViewSlot)
                        CloseExistingGameViewsForStreaming(null);
                }

                ApplyCompositeLayout(request, logicalW, logicalH, resolvedApplyMode);
                if (resolvedApplyMode != CompositeLayoutApplyMode.PreserveExisting)
                    TryActivateCompositeSlot(request.focusedSlotId);

                int physW = (Mathf.RoundToInt(logicalW * DPIScale) + 1) & ~1;
                int physH = (Mathf.RoundToInt(logicalH * DPIScale) + 1) & ~1;

                if (!nativeAlreadyStarted)
                {
                    int nativeResult = NativeWindowBridgeAPI.NWB_StartOffscreenCapture(fps, physW, physH);
                    if (nativeResult != 1)
                    {
                        CodelyLogger.LogError("[NWB-Composite] Native StartOffscreenCapture failed");
                        return false;
                    }
                }

                bool wasAlreadyComposite = s_CompositeActive;
                s_CompositeActive = true;
                s_OffscreenActive = true;
                s_UseRenderTextureFallback =
                    (PlayerSettings.colorSpace == ColorSpace.Gamma);
                if (s_UseRenderTextureFallback)
                    CodelyLogger.Log("[NWB-Diag] Gamma color space detected — using PrintWindow fallback (no AuxBackBufferManager)");
                s_OffscreenFps = fps;
                if (!wasAlreadyComposite)
                {
                    s_OffscreenFrameCount = 0;
                    s_CompositeLastViewCount = 0;
                }
                s_CompositeSkipFrames = 0;
                s_OffscreenTarget = null;
                s_OffscreenTargetType = null;
                s_NextCaptureTime = 0;
                s_HasFrontendHeartbeat = false;
                s_LastFrontendHeartbeatTime = EditorApplication.timeSinceStartup;
                RegisterOffscreenLoop();
                RegisterSelectionChangeListener();

                MakeAllWindowsTransparent();
                DeactivateUnityKeepWindows();
#if UNITY_EDITOR_OSX
                ShowStreamingMaskWindow();
#endif
#if UNITY_EDITOR_WIN
                DeferStreamingMaskWindow();
#endif
                InitCompositeWindowTracking();

                // Cache the request JSON for domain reload auto-resume.
                s_LastCompositeRequestJson = requestJson;

                CodelyLogger.Log($"[NWB-Composite] Started slots={s_CompositeSlots.Count} canvas={logicalW}x{logicalH} phys={physW}x{physH} @{fps}fps nativeSkipped={nativeAlreadyStarted}");
                return true;
            }
            catch (Exception ex)
            {
                CodelyLogger.LogError($"[NWB-Composite] Start failed: {ex.Message}\n{ex.StackTrace}");
                return false;
            }
#else
            return false;
#endif
        }

        private static void EnsureCompositeRenderTargets(int logicalW, int logicalH)
        {
            logicalW = Mathf.Max((logicalW + 1) & ~1, 2);
            logicalH = Mathf.Max((logicalH + 1) & ~1, 2);
            int physW = (Mathf.RoundToInt(logicalW * DPIScale) + 1) & ~1;
            int physH = (Mathf.RoundToInt(logicalH * DPIScale) + 1) & ~1;

#if UNITY_EDITOR_WIN
            var rtReadWrite = RenderTextureReadWrite.Linear;
            bool texLinear = true;
#else
            var rtReadWrite = RenderTextureReadWrite.Default;
            bool texLinear = false;
#endif
            if (s_CompositeRT == null || s_CompositeRT.width != physW || s_CompositeRT.height != physH)
            {
                if (s_CompositeRT != null)
                {
                    s_CompositeRT.Release();
                    UnityEngine.Object.DestroyImmediate(s_CompositeRT);
                }
                s_CompositeRT = new RenderTexture(physW, physH, 0, RenderTextureFormat.BGRA32, rtReadWrite)
                {
                    name = "__NWB_CompositeRT__",
                    useMipMap = false,
                    autoGenerateMips = false
                };
                s_CompositeRT.Create();
            }

            if (s_CompositeReadbackTex == null || s_CompositeReadbackTex.width != physW || s_CompositeReadbackTex.height != physH)
            {
                if (s_CompositeReadbackTex != null)
                    UnityEngine.Object.DestroyImmediate(s_CompositeReadbackTex);
                s_CompositeReadbackTex = new Texture2D(physW, physH, TextureFormat.BGRA32, false, texLinear);
            }

            s_CompositeLogicalWidth = logicalW;
            s_CompositeLogicalHeight = logicalH;
        }

        private static CompositeLayoutApplyMode ResolveCompositeLayoutApplyMode(
            CompositeStreamRequest request, CompositeLayoutApplyMode requestedMode)
        {
            if (requestedMode != CompositeLayoutApplyMode.Auto)
                return requestedMode;

            string requested = request?.applyMode ?? string.Empty;
            if (string.Equals(requested, "append_single", StringComparison.OrdinalIgnoreCase))
                return CompositeLayoutApplyMode.AppendSingle;
            if (string.Equals(requested, "strict_replace", StringComparison.OrdinalIgnoreCase))
                return CompositeLayoutApplyMode.StrictReplace;
            if (string.Equals(requested, "preserve_existing", StringComparison.OrdinalIgnoreCase))
                return CompositeLayoutApplyMode.PreserveExisting;
            if (string.Equals(requested, "replace_managed_keep_native", StringComparison.OrdinalIgnoreCase))
                return CompositeLayoutApplyMode.ReplaceManagedKeepNative;

            int validCount = 0;
            if (request?.slots != null)
            {
                foreach (CompositeSlotRequest slot in request.slots)
                {
                    if (slot != null && !string.IsNullOrEmpty(slot.windowType))
                        validCount++;
                }
            }

            // UX rule:
            // - Single-slot request means incremental add/update; keep existing slots.
            // - Multi-slot request means strict layout snapshot; replace by request.
            return validCount <= 1
                ? CompositeLayoutApplyMode.AppendSingle
                : CompositeLayoutApplyMode.StrictReplace;
        }

        private static string GetLastCompositeLayoutPreset()
        {
            if (string.IsNullOrEmpty(s_LastCompositeRequestJson))
                return string.Empty;
            try
            {
                CompositeStreamRequest last = JsonUtility.FromJson<CompositeStreamRequest>(s_LastCompositeRequestJson);
                return last?.layoutPreset ?? string.Empty;
            }
            catch (Exception)
            {
                return string.Empty;
            }
        }

        private static bool ShouldPreserveCompositeLayoutForSamePreset(CompositeStreamRequest request)
        {
            if (!s_NativeOffscreenDisconnectedAwaitingRestore)
                return false;
            if (s_CompositeSlots == null || s_CompositeSlots.Count == 0)
                return false;

            string preset = request?.layoutPreset ?? string.Empty;
            if (string.IsNullOrEmpty(preset))
                return false;
            if (!string.Equals(preset, kDefaultCompositeLayoutPreset, StringComparison.Ordinal) &&
                !string.Equals(preset, kSavedCompositeLayoutPreset, StringComparison.Ordinal))
                return false;

            string lastPreset = GetLastCompositeLayoutPreset();
            if (!string.Equals(lastPreset, preset, StringComparison.Ordinal))
                return false;

            // Preserve only when current live slots can satisfy the full incoming
            // layout request. If user closed a view (e.g. default 6-slot -> 5-slot),
            // we must rebuild missing slots instead of preserving the incomplete state.
            return HasRequiredRequestedWindowTypesForPreserve(request);
        }

        private static bool HasRequiredRequestedWindowTypesForPreserve(CompositeStreamRequest request)
        {
            if (request?.slots == null || request.slots.Length == 0)
                return false;

            var required = new Dictionary<string, int>(StringComparer.Ordinal);
            foreach (CompositeSlotRequest slot in request.slots)
            {
                string type = slot?.windowType;
                if (string.IsNullOrEmpty(type))
                    continue;
                if (!required.TryGetValue(type, out int count))
                    count = 0;
                required[type] = count + 1;
            }
            if (required.Count == 0)
                return false;

            var available = new Dictionary<string, int>(StringComparer.Ordinal);
            foreach (CompositeCaptureSlot slot in s_CompositeSlots.Values)
            {
                if (slot?.Window == null)
                    continue;
                string type = slot.WindowTypeName;
                if (string.IsNullOrEmpty(type))
                    continue;
                if (!available.TryGetValue(type, out int count))
                    count = 0;
                available[type] = count + 1;
            }

            foreach (var kvp in required)
            {
                if (!available.TryGetValue(kvp.Key, out int got) || got < kvp.Value)
                    return false;
            }
            return true;
        }

        private static bool TryNormalizeSlotIdsForPresetReuse(CompositeStreamRequest request)
        {
            if (!s_NativeOffscreenDisconnectedAwaitingRestore || request?.slots == null)
                return true;

            var usedExistingIds = new HashSet<string>(StringComparer.Ordinal);
            foreach (CompositeSlotRequest req in request.slots)
            {
                string incomingId = string.IsNullOrEmpty(req?.slotId) ? req?.windowType : req.slotId;
                if (string.IsNullOrEmpty(incomingId) || req == null)
                    continue;
                if (s_CompositeSlots.ContainsKey(incomingId))
                {
                    usedExistingIds.Add(incomingId);
                    continue;
                }

                string remapFromId = null;
                foreach (var kvp in s_CompositeSlots)
                {
                    if (usedExistingIds.Contains(kvp.Key))
                        continue;
                    CompositeCaptureSlot candidate = kvp.Value;
                    if (candidate?.Window == null)
                        continue;
                    if (!string.Equals(candidate.WindowTypeName, req.windowType, StringComparison.Ordinal))
                        continue;
                    remapFromId = kvp.Key;
                    break;
                }
                if (string.IsNullOrEmpty(remapFromId))
                    continue;

                CompositeCaptureSlot slot = s_CompositeSlots[remapFromId];
                s_CompositeSlots.Remove(remapFromId);
                slot.SlotId = incomingId;
                s_CompositeSlots[incomingId] = slot;
                usedExistingIds.Add(incomingId);
                LogVerbose($"[NWB-Composite] Normalize preset reuse slotId: '{remapFromId}' -> '{incomingId}' ({req.windowType})");
            }
            return true;
        }

        private static bool TryEnsurePresetLayoutConsistencyWithoutRebuild(CompositeStreamRequest request)
        {
            if (!TryBuildPresetTargetSlotsForConsistency(request, out List<CompositeSlotRequest> targetSlots))
                return false;

            if (VerifySavedCompositeLayoutRects(targetSlots, 0.03f, out float rectError))
            {
                LogVerbose($"[NWB-Composite] Preset layout rects already aligned (maxError={rectError:F4})");
                return true;
            }

            LogVerbose($"[NWB-Composite] Preset layout rect mismatch (maxError={rectError:F4}), trying in-place tree convergence");
            if (!TryApplySavedCompositeLayoutTree(targetSlots))
                return false;
            CloseOrphanEmptyContainerWindows();

            bool alignedAfter = VerifySavedCompositeLayoutRects(targetSlots, 0.03f, out float afterError);
            if (!alignedAfter)
                CodelyLogger.LogWarning($"[NWB-Composite] In-place preset tree convergence did not reach tolerance (maxError={afterError:F4})");
            else
                LogVerbose($"[NWB-Composite] In-place preset tree convergence succeeded (maxError={afterError:F4})");
            return alignedAfter;
        }

        private static bool TryBuildPresetTargetSlotsForConsistency(
            CompositeStreamRequest request,
            out List<CompositeSlotRequest> targetSlots)
        {
            targetSlots = null;
            string preset = request?.layoutPreset ?? string.Empty;
            if (string.IsNullOrEmpty(preset))
                return false;

            if (string.Equals(preset, kSavedCompositeLayoutPreset, StringComparison.Ordinal))
            {
                targetSlots = GetValidCompositeLayoutSlots(request);
                return targetSlots != null && targetSlots.Count > 0;
            }

            if (!string.Equals(preset, kDefaultCompositeLayoutPreset, StringComparison.Ordinal))
                return false;

            if (!TryResolveDefaultLayoutSlotIds(request,
                out string hierarchySlotId,
                out string sceneSlotId,
                out string gameSlotId,
                out string projectSlotId,
                out string consoleSlotId,
                out string inspectorSlotId))
                return false;

            targetSlots = BuildDefaultCompositeLayoutSlots(
                request,
                hierarchySlotId,
                sceneSlotId,
                gameSlotId,
                projectSlotId,
                consoleSlotId,
                inspectorSlotId);
            return targetSlots != null && targetSlots.Count > 0;
        }

        private static bool IsNativeTrackedCompositeSlot(string slotId)
        {
            return !string.IsNullOrEmpty(slotId) &&
                   slotId.StartsWith("native-", StringComparison.OrdinalIgnoreCase);
        }

        /// <summary>
        /// In detached-hidden state, frontend can re-generate slotId on each restart
        /// (for example using timestamp suffixes). Rebind the incoming slotId to an
        /// existing slot with the same window type so we can reuse the old floating
        /// window instead of creating a new one.
        /// </summary>
        private static CompositeCaptureSlot TryRemapDetachedCompositeSlot(string incomingSlotId,
            string windowTypeName, HashSet<string> wanted, int logicalW, int logicalH, CompositeRect requestedRect)
        {
            if (!s_NativeOffscreenDisconnectedAwaitingRestore || string.IsNullOrEmpty(windowTypeName))
                return null;

            string reusableSlotId = null;
            CompositeCaptureSlot reusableSlot = null;
            foreach (var kvp in s_CompositeSlots)
            {
                if (wanted.Contains(kvp.Key))
                    continue;

                CompositeCaptureSlot candidate = kvp.Value;
                if (candidate?.Window == null)
                    continue;
                if (!string.Equals(candidate.WindowTypeName, windowTypeName, StringComparison.Ordinal))
                    continue;
                if (!IsDetachedRemapSizeCompatible(candidate, logicalW, logicalH, requestedRect, out string reason))
                {
                    LogVerbose($"[NWB-Composite] Skip detached remap candidate '{kvp.Key}' ({windowTypeName}): {reason}");
                    continue;
                }

                reusableSlotId = kvp.Key;
                reusableSlot = candidate;
                break;
            }

            if (reusableSlot == null)
                return null;

            if (!string.Equals(reusableSlotId, incomingSlotId, StringComparison.Ordinal))
            {
                s_CompositeSlots.Remove(reusableSlotId);
                reusableSlot.SlotId = incomingSlotId;
                s_CompositeSlots[incomingSlotId] = reusableSlot;
                LogVerbose($"[NWB-Composite] Reuse detached slot by windowType: '{reusableSlotId}' -> '{incomingSlotId}' ({windowTypeName})");
            }
            else
            {
                LogVerbose($"[NWB-Composite] Reuse detached slot: '{incomingSlotId}' ({windowTypeName})");
            }

            return reusableSlot;
        }

        private static bool IsDetachedRemapSizeCompatible(
            CompositeCaptureSlot candidate,
            int logicalW,
            int logicalH,
            CompositeRect requestedRect,
            out string reason)
        {
            reason = string.Empty;
            if (candidate?.Window == null)
            {
                reason = "candidate window is null";
                return false;
            }

            Rect nr = ClampCompositeRect(requestedRect);
            float expectedLogicalW = Mathf.Max(logicalW * nr.width, 1f);
            float expectedLogicalH = Mathf.Max(logicalH * nr.height, 1f);

            object parentView = GetParentView(candidate.Window);
            if (parentView == null)
            {
                reason = "parent view is missing";
                return false;
            }

            Rect viewRect = GetViewScreenPosition(parentView);
            if (viewRect.width <= 1f || viewRect.height <= 1f)
            {
                reason = $"invalid view size {viewRect.width:F1}x{viewRect.height:F1}";
                return false;
            }

            float expectedW = Mathf.Max(expectedLogicalW * LocalPP, 1f);
            float expectedH = Mathf.Max(expectedLogicalH * LocalPP, 1f);
            float actualW = Mathf.Max(viewRect.width * LocalPP, 1f);
            float actualH = Mathf.Max(viewRect.height * LocalPP, 1f);
            float widthTolerance = Mathf.Max(96f, expectedW * 0.25f);
            float heightTolerance = Mathf.Max(96f, expectedH * 0.25f);

            bool widthOk = Mathf.Abs(actualW - expectedW) <= widthTolerance;
            bool heightOk = Mathf.Abs(actualH - expectedH) <= heightTolerance;
            if (widthOk && heightOk)
                return true;

            reason = $"size mismatch actual={actualW:F0}x{actualH:F0} expected={expectedW:F0}x{expectedH:F0}";
            return false;
        }

        private static void ApplyCompositeLayout(CompositeStreamRequest request, int logicalW, int logicalH,
            CompositeLayoutApplyMode applyMode)
        {
            bool preserveExisting = applyMode == CompositeLayoutApplyMode.PreserveExisting;
            bool strictReplace = applyMode == CompositeLayoutApplyMode.StrictReplace;
            bool replaceManagedKeepNative = applyMode == CompositeLayoutApplyMode.ReplaceManagedKeepNative;
            bool forcePresetLayout = string.Equals(request?.layoutPreset, kDefaultCompositeLayoutPreset, StringComparison.Ordinal) ||
                                     string.Equals(request?.layoutPreset, kSavedCompositeLayoutPreset, StringComparison.Ordinal);
            // Only reuse detached slot ids for the single-slot reconnect path.
            // Multi-slot (especially default/saved preset) should rebuild against
            // the incoming layout snapshot to avoid stale docking topology.
            bool allowDetachedSlotRemap = s_NativeOffscreenDisconnectedAwaitingRestore &&
                                          request?.slots != null &&
                                          request.slots.Length == 1;
            if (preserveExisting)
            {
                // Preserve mode keeps existing docking topology and windows; re-acquire
                // handles for all alive slots even when incoming slotIds changed.
                foreach (CompositeCaptureSlot existing in s_CompositeSlots.Values)
                {
                    if (existing?.Window != null)
                        ReacquireCompositeSlotHandles(existing);
                }
            }
            var wanted = new HashSet<string>();
            foreach (CompositeSlotRequest slotRequest in request.slots)
            {
                if (slotRequest == null || string.IsNullOrEmpty(slotRequest.windowType))
                    continue;

                string slotId = string.IsNullOrEmpty(slotRequest.slotId)
                    ? slotRequest.windowType
                    : slotRequest.slotId;
                wanted.Add(slotId);

                if (s_CompositeSlots.TryGetValue(slotId, out CompositeCaptureSlot slot) &&
                    slot.Window == null)
                {
                    ReleaseCompositeSlot(slot);
                    s_CompositeSlots.Remove(slotId);
                    slot = null;
                }

                if (preserveExisting)
                {
                    // During domain-reload resume, keep current windows/rects unchanged.
                    // Only re-acquire native handles for slots that already exist.
                    if (slot != null)
                        ReacquireCompositeSlotHandles(slot);
                    continue;
                }

                if (slot == null)
                {
                    if (allowDetachedSlotRemap)
                        slot = TryRemapDetachedCompositeSlot(slotId, slotRequest.windowType, wanted, logicalW, logicalH, slotRequest.rect);
                }

                if (slot == null)
                {
                    slot = CreateCompositeSlot(slotId, slotRequest.windowType, logicalW, logicalH, slotRequest.rect);
                    if (slot == null) continue;
                    s_CompositeSlots[slotId] = slot;
                }
                else
                {
                    slot.WindowTypeName = slotRequest.windowType;
                    ReacquireCompositeSlotHandles(slot);
                    ResizeCompositeSlot(slot, logicalW, logicalH, slotRequest.rect);
                }

                slot.NormalizedRect = ClampCompositeRect(slotRequest.rect);
                slot.Window?.Repaint();
            }

            if (strictReplace || replaceManagedKeepNative)
            {
                var removeIds = new List<string>();
                foreach (string id in s_CompositeSlots.Keys)
                {
                    if (!wanted.Contains(id))
                    {
                        if (replaceManagedKeepNative && IsNativeTrackedCompositeSlot(id))
                        {
                            LogVerbose($"[NWB-Composite] Keep native slot '{id}' in ReplaceManagedKeepNative");
                            continue;
                        }
                        removeIds.Add(id);
                    }
                }
                foreach (string id in removeIds)
                {
                    LogVerbose($"[NWB-Composite] Remove slot '{id}' in mode={applyMode}");
                    ReleaseCompositeSlot(s_CompositeSlots[id]);
                    s_CompositeSlots.Remove(id);
                }
            }

            if (!preserveExisting)
            {
                ResizeCompositeWorkspaceToCanvas();
                // Preset layout (default/saved) must always converge to the
                // preset geometry, even when the request uses a non-strict
                // applyMode such as ReplaceManagedKeepNative.
                if (strictReplace || forcePresetLayout)
                    ScheduleCompositeLayoutPreset(request);
            }
        }

        private static CompositeCaptureSlot CreateCompositeSlot(string slotId, string windowTypeName, int logicalW, int logicalH, CompositeRect rect)
        {
            System.Type windowType = ResolveEditorWindowType(windowTypeName);
            if (windowType == null)
            {
                CodelyLogger.LogError($"[NWB-Composite] Window type not found: {windowTypeName}");
                return null;
            }

            EditorWindow reference = null;
            foreach (var w in Resources.FindObjectsOfTypeAll<EditorWindow>())
            {
                if (w != null && w.GetType() == windowType)
                {
                    reference = w;
                    break;
                }
            }
            bool shouldReuseExistingWindow = reference != null && ShouldReuseExistingCompositeWindow(windowTypeName);
            // Do NOT call GetWindow for types we will create floating copies of (e.g. GameView).
            // GetWindow creates a docked window whose size info (PanelSettings.
            // GetGameViewResolution) interferes with the floating copy's texture config.
            if (reference == null && !shouldReuseExistingWindow)
            {
                if (ShouldReuseExistingCompositeWindow(windowTypeName))
                    reference = EditorWindow.GetWindow(windowType, false, null, false);
            }

            EditorWindow floating = shouldReuseExistingWindow
                ? reference
                : ScriptableObject.CreateInstance(windowType) as EditorWindow;
            if (floating == null)
            {
                CodelyLogger.LogError($"[NWB-Composite] Failed to create floating window: {windowTypeName}");
                return null;
            }

            Rect nr = ClampCompositeRect(rect);
            float slotW = Mathf.Max(logicalW * DpiScaleFactor, 320f * DpiScaleFactor);
            float slotH = Mathf.Max(logicalH * DpiScaleFactor - s_TabBarOffsetY, 240f * DpiScaleFactor);
            Rect refPos = reference != null ? reference.position : new Rect(100, 100, slotW, slotH);

            // When composite is already active, existing reference windows may
            // be hidden off-screen at (-32000, -32000) physical pixels.
            // ContainerWindow.position uses DPI-scaled logical coordinates, so
            // at 200% DPI the position appears as ~(-16000, -16000).
            // Use -10000 as a safe universal off-screen threshold.
            bool refOffScreen = (refPos.x <= -10000f || refPos.y <= -10000f);
            if (refOffScreen)
                refPos = new Rect(100, 100, slotW, slotH);

            // Add subsequent slots as tabs in the existing DockArea. If a
            // layout preset is active, an EditorApplication.update operation
            // later splits those tabs after Unity has finished layout/repaint.
            object existingDockArea = FindExistingCompositeDockArea();
            bool addedDirectly = false;
            bool shouldAddAsTab = existingDockArea != null && !shouldReuseExistingWindow;
#if UNITY_EDITOR_WIN
            HashSet<IntPtr> beforeShowHwnds = null;
#endif
#if UNITY_EDITOR_OSX
            HashSet<IntPtr> beforeShowNSWindows = null;
#endif

            if (shouldAddAsTab)
            {
                try
                {
                    System.Type dockAreaType = existingDockArea.GetType();
                    MethodInfo addTab = dockAreaType.GetMethod("AddTab",
                        BindingFlags.Instance | BindingFlags.Public,
                        null,
                        new System.Type[] { typeof(EditorWindow), typeof(bool) },
                        null);
                    if (addTab != null)
                    {
                        addTab.Invoke(existingDockArea, new object[] { floating, false });
                        addedDirectly = true;
                        LogVerbose($"[NWB-Composite] AddTab {windowTypeName} directly to existing DockArea (default tab mode)");
                    }
                }
                catch (Exception ex)
                {
                    string innerMsg = ex.InnerException?.Message ?? ex.Message;
                    CodelyLogger.LogWarning($"[NWB-Composite] Direct AddTab failed for {windowTypeName}: {innerMsg}, falling back to Show()");
                }
            }

            if (!addedDirectly)
            {
#if UNITY_EDITOR_WIN
                beforeShowHwnds = new HashSet<IntPtr>(GetAllUnityHwnds());
#endif
#if UNITY_EDITOR_OSX
                beforeShowNSWindows = new HashSet<IntPtr>(GetAllNSWindows());
#endif
                if (!shouldReuseExistingWindow)
                {
                    floating.position = new Rect(refPos.x + 30f, refPos.y + 30f, slotW, slotH);
                    floating.Show();
                    floating.position = new Rect(refPos.x + 30f, refPos.y + 30f, slotW, slotH);
                }
                // Force initial IMGUI Layout+Repaint for the first standalone window.
                // Initializes GPU AuxBackBuffer and IMGUI state so the DWM
                // redirect surface has renderable content for PrintWindow capture.
                ForceDoubleLayoutRepaint(floating);
                floating.Repaint();
            }

            // Enable autoRepaintOnSceneChange for all composite windows (tabbed
            // or independent). This ensures RepaintViews(true) resets
            // m_CanBlitPaint=false, forcing full DoPaint renders.
            floating.autoRepaintOnSceneChange = true;

            var slot = new CompositeCaptureSlot
            {
                SlotId = slotId,
                WindowTypeName = windowTypeName,
                WindowType = windowType,
                Window = floating,
                OwnsWindow = !shouldReuseExistingWindow,
                CloseWindowOnRelease = shouldReuseExistingWindow,
                NormalizedRect = nr
            };
#if UNITY_EDITOR_WIN
            if (shouldReuseExistingWindow || addedDirectly)
            {
                // Window shares ContainerWindow with existing DockArea
                slot.ContainerHwnd = Cn.Tuanjie.Codely.Editor.NativeWindowHelper.GetHWND(floating);
                if (slot.ContainerHwnd != IntPtr.Zero)
                {
                    IntPtr child = GetWindow(slot.ContainerHwnd, GW_CHILD);
                    if (child != IntPtr.Zero)
                        slot.GUIViewHwnd = child;
                    LogVerbose($"[NWB-Composite] {(addedDirectly ? "Tabbed" : "Reused")} slot '{slotId}' HWND=0x{slot.ContainerHwnd.ToInt64():X}, GUIView=0x{(child != IntPtr.Zero ? child.ToInt64() : 0):X}");
                }
            }
            else
            {
                var afterShowHwnds = GetAllUnityHwnds();
                foreach (var h in afterShowHwnds)
                {
                    if (!beforeShowHwnds.Contains(h))
                    {
                        slot.ContainerHwnd = h;
                        IntPtr child = GetWindow(h, GW_CHILD);
                        if (child != IntPtr.Zero)
                            slot.GUIViewHwnd = child;
                        LogVerbose($"[NWB-Composite] Slot '{slotId}' HWND=0x{h.ToInt64():X}, GUIView=0x{(child != IntPtr.Zero ? child.ToInt64() : 0):X}");
                        break;
                    }
                }
            }

            // Get the actual GUIView HWND via EditorWindow.m_Parent.nativeHandle.
            // GetWindow(GW_CHILD) on a ContainerWindow returns RootView, not the
            // DockArea. The reflected native handle gives the correct DockArea HWND
            // which has its own D3D swap chain that PrintWindow can capture.
            IntPtr reflectedGUIView = Cn.Tuanjie.Codely.Editor.EditorWindowNativeHandleHelper.GetGUIViewHandle(floating);
            if (reflectedGUIView != IntPtr.Zero)
                slot.GUIViewHwnd = reflectedGUIView;

            LogVerbose($"[NWB-Composite] Slot '{slotId}' ContainerHwnd=0x{slot.ContainerHwnd.ToInt64():X}, GUIViewHwnd=0x{slot.GUIViewHwnd.ToInt64():X} reflected=0x{reflectedGUIView.ToInt64():X}");

            // Remove WS_EX_LAYERED from both ContainerWindow and GUIView.
            // DoPaint checks WS_EX_LAYERED and sets m_Transparent=true which
            // causes OnWindowEndRender(presentContent=false), preventing the
            // DWM redirect surface from being updated. PrintWindow then
            // captures black. Remove from both to ensure proper rendering.
            if (slot.ContainerHwnd != IntPtr.Zero)
            {
                int style = GetWindowLongW(slot.ContainerHwnd, GWL_EXSTYLE);
                if ((style & WS_EX_LAYERED) != 0)
                    SetWindowLongW(slot.ContainerHwnd, GWL_EXSTYLE, style & ~WS_EX_LAYERED);
            }
            if (slot.GUIViewHwnd != IntPtr.Zero && slot.GUIViewHwnd != slot.ContainerHwnd)
            {
                int gvStyle = GetWindowLongW(slot.GUIViewHwnd, GWL_EXSTYLE);
                if ((gvStyle & WS_EX_LAYERED) != 0)
                    SetWindowLongW(slot.GUIViewHwnd, GWL_EXSTYLE, gvStyle & ~WS_EX_LAYERED);
            }
#endif
#if UNITY_EDITOR_OSX
            if (addedDirectly)
            {
                // Share NSWindow from existing slot
                foreach (CompositeCaptureSlot existSlot in s_CompositeSlots.Values)
                {
                    if (existSlot?.Window != null && existSlot.NSWindow != IntPtr.Zero)
                    {
                        slot.NSWindow = existSlot.NSWindow;
                        break;
                    }
                }
                LogVerbose($"[NWB-Composite] Tabbed slot '{slotId}' NSWindow={slot.NSWindow}");
            }
            else if (!shouldReuseExistingWindow)
            {
                var afterShowNSWindows = GetAllNSWindows();
                foreach (var nsw in afterShowNSWindows)
                {
                    if (!beforeShowNSWindows.Contains(nsw))
                    {
                        slot.NSWindow = nsw;
                        LogVerbose($"[NWB-Composite] Slot '{slotId}' NSWindow={nsw}");
                        break;
                    }
                }
            }
#endif
            ResizeCompositeSlot(slot, logicalW, logicalH, rect);

            // Initialize the window's content for current selection.
            // InvokeSelectionChangeOnWindow rebuilds the ActiveEditorTracker
            // (loads Inspector editors for the selected object).
            if (floating != null && Selection.activeObject != null)
            {
                try { InvokeSelectionChangeOnWindow(floating); } catch (Exception) { }
            }

            // For tabbed windows: force initial Layout+Repaint AFTER editors
            // are loaded by InvokeSelectionChangeOnWindow. This ensures DoPaint
            // takes the full-render path and writes correct content into the
            // AuxBackBuffer. Without this, the GUIView's m_CanBlitPaint is true
            // (set by the first slot's SendEvent render) and subsequent
            // ForceRepaintImmediately calls blit stale content from AuxBackBuffer.
            if (addedDirectly)
            {
                ForceDoubleLayoutRepaint(floating);
                floating.Repaint();
            }

            EditorApplication.QueuePlayerLoopUpdate();

            return slot;
        }

        private static void ScheduleCompositeLayoutPreset(CompositeStreamRequest request)
        {
            if (request == null)
            {
                CancelCompositeLayoutOperation();
                return;
            }

            if (request.layoutPreset == kSavedCompositeLayoutPreset)
            {
                ScheduleSavedCompositeLayout(request);
                return;
            }

            if (request.layoutPreset != kDefaultCompositeLayoutPreset)
            {
                CancelCompositeLayoutOperation();
                return;
            }

            if (!TryResolveDefaultLayoutSlotIds(request,
                out string hierarchySlotId,
                out string sceneSlotId,
                out string gameSlotId,
                out string projectSlotId,
                out string consoleSlotId,
                out string inspectorSlotId))
                return;

            List<CompositeSlotRequest> defaultSlots = BuildDefaultCompositeLayoutSlots(
                request,
                hierarchySlotId,
                sceneSlotId,
                gameSlotId,
                projectSlotId,
                consoleSlotId,
                inspectorSlotId);
            float defaultLayoutRectError;
            if (IsDefaultCompositeLayoutAchieved(hierarchySlotId, sceneSlotId, gameSlotId, projectSlotId, consoleSlotId, inspectorSlotId) &&
                VerifySavedCompositeLayoutRects(defaultSlots, 0.03f, out defaultLayoutRectError))
                return;

            // NOTE:
            // The direct SplitView-tree rebuild path is intentionally disabled for
            // default layout on Windows. In practice this path can produce invalid
            // DockArea state after domain reload (HostView.GetExtraButtonsWidth NRE),
            // which then breaks downstream keyboard/input dispatch in Play mode.
            //
            // We fall back to the existing step-by-step layout operation, which uses
            // Unity's normal docking flow and is more stable for multi-view streams.
            LogVerbose("[NWB-Composite] Skip direct tree rebuild for default layout; using scheduled dock operations");

            if (IsDefaultCompositeLayoutAchieved(hierarchySlotId, sceneSlotId, gameSlotId, projectSlotId, consoleSlotId, inspectorSlotId))
                return;

            if (s_CompositeLayoutOperation != null &&
                s_CompositeLayoutOperation.Preset == request.layoutPreset &&
                s_CompositeLayoutOperation.HierarchySlotId == hierarchySlotId &&
                s_CompositeLayoutOperation.GameSlotId == gameSlotId &&
                s_CompositeLayoutOperation.SceneSlotId == sceneSlotId &&
                s_CompositeLayoutOperation.ProjectSlotId == projectSlotId &&
                s_CompositeLayoutOperation.ConsoleSlotId == consoleSlotId &&
                s_CompositeLayoutOperation.InspectorSlotId == inspectorSlotId)
            {
                return;
            }

            s_CompositeLayoutOperation = new CompositeLayoutOperation
            {
                Preset = request.layoutPreset,
                HierarchySlotId = hierarchySlotId,
                GameSlotId = gameSlotId,
                SceneSlotId = sceneSlotId,
                ProjectSlotId = projectSlotId,
                ConsoleSlotId = consoleSlotId,
                InspectorSlotId = inspectorSlotId,
                Step = 0,
                WaitFrames = 3,
                Attempts = 0
            };
            EditorApplication.update -= CompositeLayoutOperationTick;
            EditorApplication.update += CompositeLayoutOperationTick;
            LogVerbose("[NWB-Composite] Scheduled default layout operation");
        }

        private static void ScheduleSavedCompositeLayout(CompositeStreamRequest request)
        {
            List<CompositeSlotRequest> savedSlots = GetValidCompositeLayoutSlots(request);
            TryApplySavedCompositeLayoutTree(savedSlots);
            // After moving EditorWindows from floating ContainerWindows to the
            // main editor's DockArea, the original floating ContainerWindows are
            // left empty (no panes). Close them to prevent zombie black windows.
            CloseOrphanEmptyContainerWindows();
            CancelCompositeLayoutOperation();
        }

        private static List<CompositeSlotRequest> GetValidCompositeLayoutSlots(CompositeStreamRequest request)
        {
            var slots = new List<CompositeSlotRequest>();
            if (request?.slots == null) return slots;

            foreach (CompositeSlotRequest slot in request.slots)
            {
                if (slot == null || string.IsNullOrEmpty(slot.slotId) || string.IsNullOrEmpty(slot.windowType))
                    continue;
                slots.Add(slot);
            }

            return slots;
        }

        private static List<List<CompositeSlotRequest>> GroupCompositeSlotsByRect(List<CompositeSlotRequest> slots)
        {
            var groups = new List<List<CompositeSlotRequest>>();
            if (slots == null) return groups;

            foreach (CompositeSlotRequest slot in slots)
            {
                bool added = false;
                foreach (var group in groups)
                {
                    if (group.Count > 0 && AreCompositeRectsEquivalent(slot.rect, group[0].rect))
                    {
                        group.Add(slot);
                        added = true;
                        break;
                    }
                }
                if (!added)
                    groups.Add(new List<CompositeSlotRequest> { slot });
            }

            return groups;
        }

        private static bool AreCompositeRectsEquivalent(CompositeRect a, CompositeRect b)
        {
            Rect ar = ClampCompositeRect(a);
            Rect br = ClampCompositeRect(b);
            const float eps = 0.01f;
            return Mathf.Abs(ar.x - br.x) <= eps &&
                   Mathf.Abs(ar.y - br.y) <= eps &&
                   Mathf.Abs(ar.width - br.width) <= eps &&
                   Mathf.Abs(ar.height - br.height) <= eps;
        }

        private static CompositeLayoutNode BuildCompositeLayoutNode(List<CompositeSlotRequest> slots)
        {
            if (slots == null || slots.Count == 0) return null;
            if (slots.Count == 1) return new CompositeLayoutNode { Slot = slots[0] };

            if (TrySplitCompositeLayoutSlots(slots, true, out List<CompositeSlotRequest> first, out List<CompositeSlotRequest> second) ||
                TrySplitCompositeLayoutSlots(slots, false, out first, out second))
            {
                return new CompositeLayoutNode
                {
                    First = BuildCompositeLayoutNode(first),
                    Second = BuildCompositeLayoutNode(second),
                    Edge = IsVerticalSplit(first, second) ? "right" : "bottom"
                };
            }

            slots.Sort((a, b) =>
            {
                Rect ar = ClampCompositeRect(a.rect);
                Rect br = ClampCompositeRect(b.rect);
                int cmp = ar.x.CompareTo(br.x);
                return cmp != 0 ? cmp : ar.y.CompareTo(br.y);
            });
            return new CompositeLayoutNode
            {
                First = new CompositeLayoutNode { Slot = slots[0] },
                Second = BuildCompositeLayoutNode(slots.GetRange(1, slots.Count - 1)),
                Edge = "right"
            };
        }

        private static bool TrySplitCompositeLayoutSlots(
            List<CompositeSlotRequest> slots,
            bool vertical,
            out List<CompositeSlotRequest> first,
            out List<CompositeSlotRequest> second)
        {
            first = null;
            second = null;
            const float eps = 0.01f;
            var cuts = new List<float>();
            foreach (CompositeSlotRequest slot in slots)
            {
                Rect r = ClampCompositeRect(slot.rect);
                cuts.Add(vertical ? r.xMin : r.yMin);
                cuts.Add(vertical ? r.xMax : r.yMax);
            }
            cuts.Sort();

            foreach (float cut in cuts)
            {
                var a = new List<CompositeSlotRequest>();
                var b = new List<CompositeSlotRequest>();
                bool crosses = false;
                foreach (CompositeSlotRequest slot in slots)
                {
                    Rect r = ClampCompositeRect(slot.rect);
                    float min = vertical ? r.xMin : r.yMin;
                    float max = vertical ? r.xMax : r.yMax;
                    if (max <= cut + eps)
                        a.Add(slot);
                    else if (min >= cut - eps)
                        b.Add(slot);
                    else
                    {
                        crosses = true;
                        break;
                    }
                }
                if (!crosses && a.Count > 0 && b.Count > 0)
                {
                    first = a;
                    second = b;
                    return true;
                }
            }

            return false;
        }

        private static bool IsVerticalSplit(List<CompositeSlotRequest> first, List<CompositeSlotRequest> second)
        {
            float firstMaxX = float.MinValue;
            float secondMinX = float.MaxValue;
            foreach (CompositeSlotRequest slot in first)
                firstMaxX = Mathf.Max(firstMaxX, ClampCompositeRect(slot.rect).xMax);
            foreach (CompositeSlotRequest slot in second)
                secondMinX = Mathf.Min(secondMinX, ClampCompositeRect(slot.rect).xMin);
            return firstMaxX <= secondMinX + 0.01f;
        }

        private static bool TryApplySavedCompositeLayoutTree(List<CompositeSlotRequest> savedSlots)
        {
            if (savedSlots == null || savedSlots.Count == 0) return false;

            bool displayFrozen = false;
            try
            {
                var groups = GroupCompositeSlotsByRect(savedSlots);
                var layoutSlots = new List<CompositeSlotRequest>();
                foreach (var group in groups)
                {
                    if (group.Count > 0) layoutSlots.Add(group[0]);
                }
                if (layoutSlots.Count == 0) return false;

                CompositeLayoutNode rootNode = BuildCompositeLayoutNode(layoutSlots);
                if (rootNode == null) return false;

                object hostWindow = GetCompositeHostWindow();
                if (hostWindow == null) return false;

                Rect rootScreen = GetCompositeRootRectForTree(hostWindow);
                if (rootScreen.width <= 1f || rootScreen.height <= 1f) return false;

                SetContainerWindowFreezeDisplay(true);
                displayFrozen = true;

                var groupsByAnchor = new Dictionary<string, List<CompositeSlotRequest>>();
                foreach (var group in groups)
                {
                    if (group.Count == 0 || string.IsNullOrEmpty(group[0].slotId)) continue;
                    groupsByAnchor[group[0].slotId] = group;
                }

                Rect fullBounds = new Rect(0f, 0f, 1f, 1f);
                object rootView = BuildSavedCompositeViewTree(rootNode, groupsByAnchor, fullBounds, rootScreen.width, rootScreen.height);
                if (rootView == null) return false;

                SetViewPosition(rootView, new Rect(0f, 0f, rootScreen.width, rootScreen.height));
                SetContainerWindowRootView(hostWindow, rootView);
                ReflowCompositeSplitRecursive(rootView);
                RepaintCompositeViewRecursive(rootView);
                InvokeContainerWindowDisplayAllViews(hostWindow);
                EditorApplication.QueuePlayerLoopUpdate();
                LogVerbose("[NWB-Composite] Applied saved layout by rebuilding SplitView tree");
                return true;
            }
            catch (Exception ex)
            {
                CodelyLogger.LogWarning($"[NWB-Composite] Direct saved layout tree rebuild failed: {ex.Message}");
                return false;
            }
            finally
            {
                if (displayFrozen)
                    SetContainerWindowFreezeDisplay(false);
            }
        }

        private static object BuildSavedCompositeViewTree(
            CompositeLayoutNode node,
            Dictionary<string, List<CompositeSlotRequest>> groupsByAnchor,
            Rect parentBounds,
            float rootWidth,
            float rootHeight)
        {
            if (node == null) return null;

            Rect nodeBounds = GetCompositeLayoutNodeBounds(node);
            Rect localRect = NormalizedRectToLocalRect(nodeBounds, parentBounds, rootWidth, rootHeight);

            if (node.Slot != null)
            {
                if (!groupsByAnchor.TryGetValue(node.Slot.slotId, out List<CompositeSlotRequest> group))
                    group = new List<CompositeSlotRequest> { node.Slot };

                object dockArea = CreateUnityEditorView("UnityEditor.DockArea");
                if (dockArea == null) return null;
                SetViewPosition(dockArea, localRect);

                int movedCount = 0;
                var movedSlots = new List<CompositeCaptureSlot>();
                foreach (CompositeSlotRequest slotRequest in group)
                {
                    if (!TryGetCompositeSlot(slotRequest.slotId, out CompositeCaptureSlot slot) || slot?.Window == null)
                        continue;
                    if (!MoveCompositeWindowToDockArea(slot.Window, dockArea))
                        return null;
                    movedSlots.Add(slot);
                    movedCount++;
                }
                if (movedCount == 0) return null;

                SelectCompositeSlotTabForGroup(group);
                RepaintCompositeViewRecursive(dockArea);
                // Reacquire after dockArea repaint to avoid sampling transient window handles.
                foreach (CompositeCaptureSlot movedSlot in movedSlots)
                    ReacquireCompositeSlotHandles(movedSlot);
                return dockArea;
            }

            object splitView = CreateUnityEditorView("UnityEditor.SplitView");
            if (splitView == null) return null;
            SetSplitViewVertical(splitView, string.Equals(node.Edge, "bottom", StringComparison.OrdinalIgnoreCase));
            SetViewPosition(splitView, localRect);

            object first = BuildSavedCompositeViewTree(node.First, groupsByAnchor, nodeBounds, rootWidth, rootHeight);
            object second = BuildSavedCompositeViewTree(node.Second, groupsByAnchor, nodeBounds, rootWidth, rootHeight);
            if (first == null || second == null) return null;

            if (!AddViewChild(splitView, first) || !AddViewChild(splitView, second))
                return null;
            return splitView;
        }

        private static Rect GetCompositeLayoutNodeBounds(CompositeLayoutNode node)
        {
            if (node == null) return new Rect(0f, 0f, 1f, 1f);
            if (node.Slot != null) return ClampCompositeRect(node.Slot.rect);
            Rect first = GetCompositeLayoutNodeBounds(node.First);
            Rect second = GetCompositeLayoutNodeBounds(node.Second);
            return Rect.MinMaxRect(
                Mathf.Min(first.xMin, second.xMin),
                Mathf.Min(first.yMin, second.yMin),
                Mathf.Max(first.xMax, second.xMax),
                Mathf.Max(first.yMax, second.yMax));
        }

        private static Rect NormalizedRectToLocalRect(Rect bounds, Rect parentBounds, float rootWidth, float rootHeight)
        {
            return new Rect(
                (bounds.xMin - parentBounds.xMin) * rootWidth,
                (bounds.yMin - parentBounds.yMin) * rootHeight,
                Mathf.Max(bounds.width * rootWidth, 1f),
                Mathf.Max(bounds.height * rootHeight, 1f));
        }

        private static object CreateUnityEditorView(string typeName)
        {
            System.Type type = ResolveUnityEditorType(typeName);
            return type != null ? ScriptableObject.CreateInstance(type) : null;
        }

        private static System.Type ResolveUnityEditorType(string typeName)
        {
            if (string.IsNullOrEmpty(typeName)) return null;
            System.Type type = System.Type.GetType(typeName) ??
                               System.Type.GetType(typeName + ",UnityEditor");
            if (type != null) return type;
            foreach (var asm in System.AppDomain.CurrentDomain.GetAssemblies())
            {
                type = asm.GetType(typeName);
                if (type != null) return type;
            }
            return null;
        }

        private static Rect GetCompositeRootRectForTree(object hostWindow)
        {
            object rootSplit = GetRootSplitView(hostWindow);
            Rect rootRect = GetViewScreenPosition(rootSplit);
            if (rootRect.width > 1f && rootRect.height > 1f)
                return rootRect;

            PropertyInfo positionProp = hostWindow?.GetType().GetProperty("position",
                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            if (positionProp != null)
            {
                Rect pos = (Rect)positionProp.GetValue(hostWindow);
                return new Rect(0f, 0f, Mathf.Max(pos.width, 320f), Mathf.Max(pos.height, 240f));
            }
            return new Rect(0f, 0f, Mathf.Max(s_CompositeLogicalWidth, 320), Mathf.Max(s_CompositeLogicalHeight, 240));
        }

        private static void SetSplitViewVertical(object splitView, bool vertical)
        {
            FieldInfo verticalField = splitView?.GetType().GetField("vertical",
                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            verticalField?.SetValue(splitView, vertical);
        }

        private static bool AddViewChild(object parent, object child)
        {
            if (parent == null || child == null) return false;
            foreach (MethodInfo method in parent.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
            {
                if (method.Name != "AddChild") continue;
                ParameterInfo[] parameters = method.GetParameters();
                if (parameters.Length == 1)
                {
                    method.Invoke(parent, new object[] { child });
                    return true;
                }
            }
            return false;
        }

        private static bool MoveCompositeWindowToDockArea(EditorWindow window, object targetDockArea)
        {
            if (window == null || targetDockArea == null) return false;
            try
            {
                // Capture the source ContainerWindow BEFORE moving the EditorWindow.
                // After RemoveTab, the source DockArea may become empty, and we need
                // to close the orphaned ContainerWindow to prevent zombie black windows.
                object sourceDockArea = GetParentView(window);
                object sourceContainerWindow = sourceDockArea != null ? GetViewWindow(sourceDockArea) : null;

                if (sourceDockArea != null && sourceDockArea.GetType().Name == "DockArea")
                {
                    MethodInfo removeTab = sourceDockArea.GetType().GetMethod("RemoveTab",
                        BindingFlags.Instance | BindingFlags.Public,
                        null,
                        new System.Type[] { typeof(EditorWindow), typeof(bool), typeof(bool) },
                        null);
                    removeTab?.Invoke(sourceDockArea, new object[] { window, false, false });
                }

                MethodInfo addTab = targetDockArea.GetType().GetMethod("AddTab",
                    BindingFlags.Instance | BindingFlags.Public,
                    null,
                    new System.Type[] { typeof(EditorWindow), typeof(bool) },
                    null);
                if (addTab != null)
                    addTab.Invoke(targetDockArea, new object[] { window, false });
                else
                {
                    addTab = targetDockArea.GetType().GetMethod("AddTab",
                        BindingFlags.Instance | BindingFlags.Public,
                        null,
                        new System.Type[] { typeof(EditorWindow) },
                        null);
                    if (addTab == null) return false;
                    addTab.Invoke(targetDockArea, new object[] { window });
                }

                // After moving, close the source ContainerWindow if it's now empty.
                // This unifies behavior with "添加视图" path where EditorWindow.Close()
                // on the last tab destroys the ContainerWindow naturally.
                if (sourceContainerWindow != null)
                {
                    try
                    {
                        // Check if source container is different from target container
                        object targetContainerWindow = GetViewWindow(targetDockArea);
                        if (targetContainerWindow != null && !object.ReferenceEquals(sourceContainerWindow, targetContainerWindow))
                        {
                            // Source and target are different ContainerWindows.
                            // Check if source ContainerWindow is now empty (no panes).
                            if (!ViewTreeHasDockPanes(
                                    sourceContainerWindow.GetType().GetField("m_RootView",
                                        BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(sourceContainerWindow)))
                            {
                                MethodInfo closeMethod = sourceContainerWindow.GetType().GetMethod("Close",
                                    BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                                closeMethod?.Invoke(sourceContainerWindow, null);
                                LogVerbose("[NWB-Composite] Closed empty source ContainerWindow after MoveCompositeWindowToDockArea");
                            }
                        }
                    }
                    catch (Exception) { }
                }

                return true;
            }
            catch (Exception ex)
            {
                CodelyLogger.LogWarning($"[NWB-Composite] Move window to rebuilt DockArea failed: {ex.Message}");
                return false;
            }
        }

        private static void SelectCompositeSlotTabForGroup(List<CompositeSlotRequest> group)
        {
            if (group == null || group.Count == 0) return;
            foreach (CompositeSlotRequest slotRequest in group)
            {
                if (TryGetCompositeSlot(slotRequest.slotId, out CompositeCaptureSlot slot))
                {
                    SelectCompositeSlotTab(slot);
                    return;
                }
            }
        }

        private static void SetContainerWindowRootView(object hostWindow, object rootView)
        {
            PropertyInfo rootViewProp = hostWindow?.GetType().GetProperty("rootView",
                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            rootViewProp?.SetValue(hostWindow, rootView);
        }

        private static void InvokeContainerWindowDisplayAllViews(object hostWindow)
        {
            MethodInfo displayAllViews = hostWindow?.GetType().GetMethod("DisplayAllViews",
                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            displayAllViews?.Invoke(hostWindow, null);
        }

        private static void SetContainerWindowFreezeDisplay(bool freeze)
        {
            System.Type containerWindowType = ResolveUnityEditorType("UnityEditor.ContainerWindow");
            MethodInfo setFreezeDisplay = containerWindowType?.GetMethod("SetFreezeDisplay",
                BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
            setFreezeDisplay?.Invoke(null, new object[] { freeze });
        }

        private static bool TryResolveDefaultLayoutSlotIds(
            CompositeStreamRequest request,
            out string hierarchySlotId,
            out string sceneSlotId,
            out string gameSlotId,
            out string projectSlotId,
            out string consoleSlotId,
            out string inspectorSlotId)
        {
            hierarchySlotId = null;
            sceneSlotId = null;
            gameSlotId = null;
            projectSlotId = null;
            consoleSlotId = null;
            inspectorSlotId = null;
            if (request?.slots == null) return false;

            foreach (CompositeSlotRequest slot in request.slots)
            {
                if (slot == null || string.IsNullOrEmpty(slot.slotId) || string.IsNullOrEmpty(slot.windowType))
                    continue;
                if (slot.windowType.Contains("SceneHierarchyWindow"))
                    hierarchySlotId = slot.slotId;
                else if (slot.windowType.Contains("SceneView"))
                    sceneSlotId = slot.slotId;
                else if (slot.windowType.Contains("GameView"))
                    gameSlotId = slot.slotId;
                else if (slot.windowType.Contains("ProjectBrowser"))
                    projectSlotId = slot.slotId;
                else if (slot.windowType.Contains("ConsoleWindow"))
                    consoleSlotId = slot.slotId;
                else if (slot.windowType.Contains("InspectorWindow"))
                    inspectorSlotId = slot.slotId;
            }

            return !string.IsNullOrEmpty(hierarchySlotId) &&
                   !string.IsNullOrEmpty(sceneSlotId) &&
                   !string.IsNullOrEmpty(gameSlotId) &&
                   !string.IsNullOrEmpty(projectSlotId) &&
                   !string.IsNullOrEmpty(consoleSlotId) &&
                   !string.IsNullOrEmpty(inspectorSlotId);
        }

        private static List<CompositeSlotRequest> BuildDefaultCompositeLayoutSlots(
            CompositeStreamRequest request,
            string hierarchySlotId,
            string sceneSlotId,
            string gameSlotId,
            string projectSlotId,
            string consoleSlotId,
            string inspectorSlotId)
        {
            var slotsById = new Dictionary<string, CompositeSlotRequest>();
            if (request?.slots != null)
            {
                foreach (CompositeSlotRequest slot in request.slots)
                {
                    if (slot == null || string.IsNullOrEmpty(slot.slotId)) continue;
                    slotsById[slot.slotId] = slot;
                }
            }

            const float rootWidth = 1206f;
            const float rootHeight = 665f;
            float leftWidth = 921f / rootWidth;
            float hierarchyWidth = 228f / rootWidth;
            float sceneWidth = 693f / rootWidth;
            float topHeight = 394f / rootHeight;
            float bottomHeight = 271f / rootHeight;
            float inspectorX = 921f / rootWidth;
            float inspectorWidth = 285f / rootWidth;

            var slots = new List<CompositeSlotRequest>();
            AddDefaultCompositeLayoutSlot(slots, slotsById, hierarchySlotId, 0f, 0f, hierarchyWidth, topHeight);
            AddDefaultCompositeLayoutSlot(slots, slotsById, sceneSlotId, hierarchyWidth, 0f, sceneWidth, topHeight);
            AddDefaultCompositeLayoutSlot(slots, slotsById, gameSlotId, hierarchyWidth, 0f, sceneWidth, topHeight);
            AddDefaultCompositeLayoutSlot(slots, slotsById, projectSlotId, 0f, topHeight, leftWidth, bottomHeight);
            AddDefaultCompositeLayoutSlot(slots, slotsById, consoleSlotId, 0f, topHeight, leftWidth, bottomHeight);
            AddDefaultCompositeLayoutSlot(slots, slotsById, inspectorSlotId, inspectorX, 0f, inspectorWidth, 1f);
            return slots;
        }

        private static void AddDefaultCompositeLayoutSlot(
            List<CompositeSlotRequest> slots,
            Dictionary<string, CompositeSlotRequest> slotsById,
            string slotId,
            float x,
            float y,
            float w,
            float h)
        {
            if (string.IsNullOrEmpty(slotId) || !slotsById.TryGetValue(slotId, out CompositeSlotRequest source))
                return;

            slots.Add(new CompositeSlotRequest
            {
                slotId = source.slotId,
                windowType = source.windowType,
                rect = new CompositeRect
                {
                    x = x,
                    y = y,
                    w = w,
                    h = h
                }
            });
        }

        private static void CompositeLayoutOperationTick()
        {
            CompositeLayoutOperation op = s_CompositeLayoutOperation;
            if (op == null)
            {
                EditorApplication.update -= CompositeLayoutOperationTick;
                return;
            }

            if (!s_CompositeActive)
            {
                CancelCompositeLayoutOperation();
                return;
            }

            if (op.WaitFrames > 0)
            {
                op.WaitFrames--;
                RepaintCompositeLayoutOperationSlots(op);
                return;
            }

            if (!TryGetCompositeSlot(op.HierarchySlotId, out CompositeCaptureSlot hierarchySlot) ||
                !TryGetCompositeSlot(op.SceneSlotId, out CompositeCaptureSlot sceneSlot) ||
                !TryGetCompositeSlot(op.GameSlotId, out CompositeCaptureSlot gameSlot) ||
                !TryGetCompositeSlot(op.ProjectSlotId, out CompositeCaptureSlot projectSlot) ||
                !TryGetCompositeSlot(op.ConsoleSlotId, out CompositeCaptureSlot consoleSlot) ||
                !TryGetCompositeSlot(op.InspectorSlotId, out CompositeCaptureSlot inspectorSlot))
            {
                RetryCompositeLayoutOperation("waiting for default layout slots");
                return;
            }

            switch (op.Step)
            {
                case 0:
                    ReacquireCompositeSlotHandles(hierarchySlot);
                    ReacquireCompositeSlotHandles(sceneSlot);
                    ReacquireCompositeSlotHandles(gameSlot);
                    ReacquireCompositeSlotHandles(projectSlot);
                    ReacquireCompositeSlotHandles(consoleSlot);
                    ReacquireCompositeSlotHandles(inspectorSlot);
                    SelectCompositeSlotTab(sceneSlot);
                    op.Step = 1;
                    op.Attempts = 0;
                    op.WaitFrames = 2;
                    return;
                case 1:
                    if (!AreCompositeSlotsInDifferentDockAreas(sceneSlot, inspectorSlot))
                    {
                        if (!TryDockCompositeSlotViaSplitView(inspectorSlot, op.SceneSlotId, "right"))
                        {
                            RetryCompositeLayoutOperation("docking Inspector to the right");
                            return;
                        }
                        ReacquireCompositeSlotHandles(inspectorSlot);
                    }
                    op.Step = 2;
                    op.Attempts = 0;
                    op.WaitFrames = 3;
                    return;
                case 2:
                    if (!AreCompositeSlotsInDifferentDockAreas(sceneSlot, projectSlot))
                    {
                        if (!TryDockCompositeSlotViaSplitView(projectSlot, op.SceneSlotId, "bottom"))
                        {
                            RetryCompositeLayoutOperation("docking Project to the bottom");
                            return;
                        }
                        ReacquireCompositeSlotHandles(projectSlot);
                    }
                    op.Step = 3;
                    op.Attempts = 0;
                    op.WaitFrames = 3;
                    return;
                case 3:
                    if (!AreCompositeSlotsInSameDockArea(projectSlot, consoleSlot))
                    {
                        if (!TryMoveCompositeSlotAsTab(consoleSlot, op.ProjectSlotId))
                        {
                            RetryCompositeLayoutOperation("tabbing Console with Project");
                            return;
                        }
                        ReacquireCompositeSlotHandles(consoleSlot);
                    }
                    SelectCompositeSlotTab(projectSlot);
                    op.Step = 4;
                    op.Attempts = 0;
                    op.WaitFrames = 2;
                    return;
                case 4:
                    if (!AreCompositeSlotsInDifferentDockAreas(hierarchySlot, sceneSlot))
                    {
                        if (!TryDockCompositeSlotViaSplitView(hierarchySlot, op.SceneSlotId, "left"))
                        {
                            RetryCompositeLayoutOperation("docking Hierarchy to the left");
                            return;
                        }
                        ReacquireCompositeSlotHandles(hierarchySlot);
                    }
                    SelectCompositeSlotTab(hierarchySlot);
                    SelectCompositeSlotTab(sceneSlot);
                    op.Step = 5;
                    op.Attempts = 0;
                    op.WaitFrames = 3;
                    return;
                default:
                    SelectCompositeSlotTab(hierarchySlot);
                    SelectCompositeSlotTab(sceneSlot);
                    SelectCompositeSlotTab(projectSlot);
                    if (IsDefaultCompositeLayoutAchieved(op.HierarchySlotId, op.SceneSlotId, op.GameSlotId, op.ProjectSlotId, op.ConsoleSlotId, op.InspectorSlotId))
                    {
                        LogVerbose("[NWB-Composite] Default layout operation completed");
                        CancelCompositeLayoutOperation();
                    }
                    else
                    {
                        op.Step = 1;
                        RetryCompositeLayoutOperation("verifying default layout");
                    }
                    return;
            }
        }

        private static bool TryGetCompositeSlot(string slotId, out CompositeCaptureSlot slot)
        {
            slot = null;
            return !string.IsNullOrEmpty(slotId) &&
                   s_CompositeSlots.TryGetValue(slotId, out slot) &&
                   slot?.Window != null;
        }

        private static void TryActivateCompositeSlot(string slotId)
        {
            if (!TryGetCompositeSlot(slotId, out CompositeCaptureSlot slot) || slot.Window == null)
                return;
            if (SelectCompositeSlotTab(slot))
            {
                LogVerbose($"[NWB-Composite] Activated reserved slot '{slotId}' ({slot.WindowTypeName})");
            } else {
                CodelyLogger.LogWarning($"[NWB-Composite] Activate slot '{slotId}' failed");
            }
        }

        private static CompositeCaptureSlot FindCompositeSlotByWindow(EditorWindow window)
        {
            if (window == null || s_CompositeSlots == null) return null;
            foreach (CompositeCaptureSlot slot in s_CompositeSlots.Values)
            {
                if (slot?.Window == window)
                    return slot;
            }
            return null;
        }

        private static void RepaintCompositeLayoutOperationSlots(CompositeLayoutOperation op)
        {
            if (op == null) return;
            if (TryGetCompositeSlot(op.HierarchySlotId, out CompositeCaptureSlot hierarchySlot))
                hierarchySlot.Window.Repaint();
            if (TryGetCompositeSlot(op.SceneSlotId, out CompositeCaptureSlot sceneSlot))
                sceneSlot.Window.Repaint();
            if (TryGetCompositeSlot(op.GameSlotId, out CompositeCaptureSlot gameSlot))
                gameSlot.Window.Repaint();
            if (TryGetCompositeSlot(op.ProjectSlotId, out CompositeCaptureSlot projectSlot))
                projectSlot.Window.Repaint();
            if (TryGetCompositeSlot(op.ConsoleSlotId, out CompositeCaptureSlot consoleSlot))
                consoleSlot.Window.Repaint();
            if (TryGetCompositeSlot(op.InspectorSlotId, out CompositeCaptureSlot inspectorSlot))
                inspectorSlot.Window.Repaint();
            EditorApplication.QueuePlayerLoopUpdate();
        }

        private static void RetryCompositeLayoutOperation(string reason)
        {
            CompositeLayoutOperation op = s_CompositeLayoutOperation;
            if (op == null) return;
            op.Attempts++;
            if (op.Attempts > 12)
            {
                if (string.Equals(op.Preset, kDefaultCompositeLayoutPreset, StringComparison.Ordinal))
                {
                    if (TryApplyDefaultLayoutTreeFallback(op))
                    {
                        LogVerbose($"[NWB-Composite] Default layout fallback tree rebuild succeeded after '{reason}'");
                        CancelCompositeLayoutOperation();
                        return;
                    }
                }
                CodelyLogger.LogWarning($"[NWB-Composite] Default layout operation stopped while {reason}");
                CancelCompositeLayoutOperation();
                return;
            }
            op.WaitFrames = 2;
            RepaintCompositeLayoutOperationSlots(op);
        }

        private static bool TryApplyDefaultLayoutTreeFallback(CompositeLayoutOperation op)
        {
            if (op == null) return false;
            if (string.IsNullOrEmpty(op.HierarchySlotId) ||
                string.IsNullOrEmpty(op.SceneSlotId) ||
                string.IsNullOrEmpty(op.GameSlotId) ||
                string.IsNullOrEmpty(op.ProjectSlotId) ||
                string.IsNullOrEmpty(op.ConsoleSlotId) ||
                string.IsNullOrEmpty(op.InspectorSlotId))
                return false;

            var request = new CompositeStreamRequest();
            var requestSlots = new List<CompositeSlotRequest>();
            TryAppendCurrentSlotForFallback(requestSlots, op.HierarchySlotId);
            TryAppendCurrentSlotForFallback(requestSlots, op.SceneSlotId);
            TryAppendCurrentSlotForFallback(requestSlots, op.GameSlotId);
            TryAppendCurrentSlotForFallback(requestSlots, op.ProjectSlotId);
            TryAppendCurrentSlotForFallback(requestSlots, op.ConsoleSlotId);
            TryAppendCurrentSlotForFallback(requestSlots, op.InspectorSlotId);
            request.slots = requestSlots.ToArray();
            if (request.slots.Length < 6)
                return false;

            List<CompositeSlotRequest> defaultSlots = BuildDefaultCompositeLayoutSlots(
                request,
                op.HierarchySlotId,
                op.SceneSlotId,
                op.GameSlotId,
                op.ProjectSlotId,
                op.ConsoleSlotId,
                op.InspectorSlotId);
            if (defaultSlots == null || defaultSlots.Count == 0)
                return false;

            if (!TryApplySavedCompositeLayoutTree(defaultSlots))
                return false;
            CloseOrphanEmptyContainerWindows();
            return true;
        }

        private static void TryAppendCurrentSlotForFallback(List<CompositeSlotRequest> slots, string slotId)
        {
            if (slots == null || string.IsNullOrEmpty(slotId))
                return;
            if (!s_CompositeSlots.TryGetValue(slotId, out CompositeCaptureSlot slot))
                return;
            if (slot?.Window == null)
                return;

            slots.Add(new CompositeSlotRequest
            {
                slotId = slotId,
                windowType = slot.WindowTypeName ?? slot.Window.GetType().FullName
            });
        }

        private static void CancelCompositeLayoutOperation()
        {
            s_CompositeLayoutOperation = null;
            EditorApplication.update -= CompositeLayoutOperationTick;
        }

        private static bool IsDefaultCompositeLayoutAchieved(
            string hierarchySlotId,
            string sceneSlotId,
            string gameSlotId,
            string projectSlotId,
            string consoleSlotId,
            string inspectorSlotId)
        {
            if (!TryGetCompositeSlot(hierarchySlotId, out CompositeCaptureSlot hierarchySlot) ||
                !TryGetCompositeSlot(sceneSlotId, out CompositeCaptureSlot sceneSlot) ||
                !TryGetCompositeSlot(gameSlotId, out CompositeCaptureSlot gameSlot) ||
                !TryGetCompositeSlot(projectSlotId, out CompositeCaptureSlot projectSlot) ||
                !TryGetCompositeSlot(consoleSlotId, out CompositeCaptureSlot consoleSlot) ||
                !TryGetCompositeSlot(inspectorSlotId, out CompositeCaptureSlot inspectorSlot))
                return false;

            object hierarchyDock = GetParentView(hierarchySlot.Window);
            object sceneDock = GetParentView(sceneSlot.Window);
            object gameDock = GetParentView(gameSlot.Window);
            object projectDock = GetParentView(projectSlot.Window);
            object consoleDock = GetParentView(consoleSlot.Window);
            object inspectorDock = GetParentView(inspectorSlot.Window);
            return hierarchyDock != null &&
                   sceneDock != null &&
                   gameDock != null &&
                   projectDock != null &&
                   consoleDock != null &&
                   inspectorDock != null &&
                   object.ReferenceEquals(sceneDock, gameDock) &&
                   object.ReferenceEquals(projectDock, consoleDock) &&
                   !object.ReferenceEquals(hierarchyDock, sceneDock) &&
                   !object.ReferenceEquals(sceneDock, projectDock) &&
                   !object.ReferenceEquals(projectDock, inspectorDock) &&
                   !object.ReferenceEquals(sceneDock, inspectorDock) &&
                   !object.ReferenceEquals(hierarchyDock, inspectorDock);
        }

        private static bool AreCompositeSlotsInDifferentDockAreas(CompositeCaptureSlot first, CompositeCaptureSlot second)
        {
            object firstDock = first?.Window != null ? GetParentView(first.Window) : null;
            object secondDock = second?.Window != null ? GetParentView(second.Window) : null;
            return firstDock != null && secondDock != null && !object.ReferenceEquals(firstDock, secondDock);
        }

        private static bool AreCompositeSlotsInSameDockArea(CompositeCaptureSlot first, CompositeCaptureSlot second)
        {
            object firstDock = first?.Window != null ? GetParentView(first.Window) : null;
            object secondDock = second?.Window != null ? GetParentView(second.Window) : null;
            return firstDock != null && secondDock != null && object.ReferenceEquals(firstDock, secondDock);
        }

        private static bool TryMoveCompositeSlotAsTab(CompositeCaptureSlot slot, string targetSlotId)
        {
            if (slot?.Window == null || string.IsNullOrEmpty(targetSlotId))
                return false;
            if (!s_CompositeSlots.TryGetValue(targetSlotId, out CompositeCaptureSlot targetSlot) || targetSlot?.Window == null)
                return false;

            try
            {
                object sourceDockArea = GetParentView(slot.Window);
                object targetDockArea = GetParentView(targetSlot.Window);
                if (sourceDockArea == null || targetDockArea == null)
                    return false;
                if (object.ReferenceEquals(sourceDockArea, targetDockArea))
                    return true;

                MethodInfo removeTab = sourceDockArea.GetType().GetMethod("RemoveTab",
                    BindingFlags.Instance | BindingFlags.Public,
                    null,
                    new System.Type[] { typeof(EditorWindow), typeof(bool), typeof(bool) },
                    null);
                MethodInfo addTab = targetDockArea.GetType().GetMethod("AddTab",
                    BindingFlags.Instance | BindingFlags.Public,
                    null,
                    new System.Type[] { typeof(EditorWindow), typeof(bool) },
                    null);
                if (removeTab == null || addTab == null)
                    return false;

                removeTab.Invoke(sourceDockArea, new object[] { slot.Window, true, false });
                addTab.Invoke(targetDockArea, new object[] { slot.Window, false });
                SelectCompositeSlotTab(targetSlot);
                return true;
            }
            catch (Exception ex)
            {
                string innerMsg = ex.InnerException?.Message ?? ex.Message;
                CodelyLogger.LogWarning($"[NWB-Composite] Move slot '{slot.SlotId}' as tab failed: {innerMsg}");
                return false;
            }
        }

        private static bool SelectCompositeSlotTab(CompositeCaptureSlot slot)
        {
            if (slot?.Window == null) return false;
            try
            {
                object dockArea = GetParentView(slot.Window);
                if (dockArea == null) return false;
                FieldInfo panesField = dockArea.GetType().GetField("m_Panes",
                    BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
                object panesObj = panesField?.GetValue(dockArea);
                if (!(panesObj is System.Collections.IList panes)) return false;
                int index = panes.IndexOf(slot.Window);
                if (index < 0) return false;
                PropertyInfo selectedProp = dockArea.GetType().GetProperty("selected",
                    BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                selectedProp?.SetValue(dockArea, index);
                MethodInfo updateTitle = dockArea.GetType().GetMethod("UpdateWindowTitle",
                    BindingFlags.Instance | BindingFlags.NonPublic,
                    null,
                    new System.Type[] { typeof(EditorWindow) },
                    null);
                updateTitle?.Invoke(dockArea, new object[] { slot.Window });
                MethodInfo repaint = dockArea.GetType().GetMethod("Repaint",
                    BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                repaint?.Invoke(dockArea, null);
                ForceDoubleLayoutRepaint(slot.Window);
                slot.Window.Repaint();
                return true;
            }
            catch (Exception ex)
            {
                string innerMsg = ex.InnerException?.Message ?? ex.Message;
                CodelyLogger.LogWarning($"[NWB-Composite] Select slot tab failed for '{slot.SlotId}': {innerMsg}");
                return false;
            }
        }

        private static bool TryDockCompositeSlotViaSplitView(CompositeCaptureSlot slot, string targetSlotId, string dockEdge)
        {
            if (slot?.Window == null || string.IsNullOrEmpty(targetSlotId) || string.IsNullOrEmpty(dockEdge))
                return false;
            if (!s_CompositeSlots.TryGetValue(targetSlotId, out CompositeCaptureSlot targetSlot) || targetSlot?.Window == null)
                return false;

            object dockAreaForDragReset = null;
            try
            {
                object targetDockArea = GetParentView(targetSlot.Window);
                object sourceDockArea = GetParentView(slot.Window);
                if (targetDockArea == null || sourceDockArea == null) return false;
                dockAreaForDragReset = sourceDockArea;

                Rect targetRect = GetViewScreenPosition(targetDockArea);
                if (targetRect.width <= 1f || targetRect.height <= 1f) return false;

                Vector2 screenPos;
                switch (dockEdge)
                {
                    case "left":
                        screenPos = new Vector2(targetRect.xMin + 2f, targetRect.center.y);
                        break;
                    case "right":
                        screenPos = new Vector2(targetRect.xMax - 2f, targetRect.center.y);
                        break;
                    case "bottom":
                        screenPos = new Vector2(targetRect.center.x, targetRect.yMax - 2f);
                        break;
                    default:
                        CodelyLogger.LogWarning($"[NWB-Composite] Unsupported dock edge '{dockEdge}' for slot '{slot.SlotId}'");
                        return false;
                }

                FieldInfo originalDragSourceField = sourceDockArea.GetType().GetField("s_OriginalDragSource",
                    BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
                originalDragSourceField?.SetValue(null, sourceDockArea);
                FieldInfo dragPaneField = sourceDockArea.GetType().GetField("s_DragPane",
                    BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
                dragPaneField?.SetValue(null, slot.Window);
                FieldInfo ignoreDockingField = sourceDockArea.GetType().GetField("s_IgnoreDockingForView",
                    BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
                FieldInfo panesField = sourceDockArea.GetType().GetField("m_Panes",
                    BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
                int paneCount = panesField?.GetValue(sourceDockArea) is System.Collections.ICollection panes
                    ? panes.Count
                    : 0;
                ignoreDockingField?.SetValue(null, paneCount == 1 ? sourceDockArea : null);

                object hostWindow = GetViewWindow(targetDockArea);
                object rootSplit = GetRootSplitView(hostWindow);
                if (rootSplit == null) return false;

                MethodInfo dragOver = rootSplit.GetType().GetMethod("DragOver",
                    BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
                    null,
                    new System.Type[] { typeof(EditorWindow), typeof(Vector2) },
                    null);
                object dropInfo = dragOver?.Invoke(rootSplit, new object[] { slot.Window, screenPos });
                if (dropInfo == null)
                {
                    CodelyLogger.LogWarning($"[NWB-Composite] DragOver returned null for slot '{slot.SlotId}' edge={dockEdge}");
                    return false;
                }

                MethodInfo performDrop = rootSplit.GetType().GetMethod("PerformDrop",
                    BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
                    null,
                    new System.Type[] { typeof(EditorWindow), dropInfo.GetType(), typeof(Vector2) },
                    null);
                if (performDrop == null) return false;

                object result = performDrop.Invoke(rootSplit, new object[] { slot.Window, dropInfo, screenPos });
                bool ok = result is bool b && b;
                if (ok)
                {
                    SelectCompositeSlotTab(slot);
                    LogVerbose($"[NWB-Composite] Docked slot '{slot.SlotId}' to '{targetSlotId}' edge={dockEdge} via SplitView.PerformDrop");
                }
                return ok;
            }
            catch (Exception ex)
            {
                string innerMsg = ex.InnerException?.Message ?? ex.Message;
                CodelyLogger.LogWarning($"[NWB-Composite] SplitView docking failed for slot '{slot.SlotId}': {innerMsg}");
                return false;
            }
            finally
            {
                ResetCompositeDockAreaDragState(dockAreaForDragReset, slot);
            }
        }

        private static void ResetCompositeDockAreaDragState(object dockArea, CompositeCaptureSlot slot)
        {
            if (dockArea == null) return;

            try
            {
                System.Type dockAreaType = dockArea.GetType();
                dockAreaType.GetField("s_DragPane",
                    BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public)?.SetValue(null, null);
                dockAreaType.GetField("s_DropInfo",
                    BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public)?.SetValue(null, null);
                dockAreaType.GetField("s_PlaceholderPos",
                    BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public)?.SetValue(null, -1);
                dockAreaType.GetField("s_IsDragging",
                    BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public)?.SetValue(null, false);
                dockAreaType.GetField("s_OriginalDragSource",
                    BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public)?.SetValue(null, null);
                dockAreaType.GetField("s_IgnoreDockingForView",
                    BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public)?.SetValue(null, null);

                object newDockArea = slot?.Window != null ? GetParentView(slot.Window) : dockArea;
                MethodInfo repaint = newDockArea?.GetType().GetMethod("Repaint",
                    BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                repaint?.Invoke(newDockArea, null);
            }
            catch (Exception ex)
            {
                CodelyLogger.LogWarning($"[NWB-Composite] DockArea drag state reset failed for '{slot?.SlotId}': {ex.Message}");
            }
        }

        private static bool VerifySavedCompositeLayoutRects(
            List<CompositeSlotRequest> savedSlots,
            float tolerance,
            out float maxError)
        {
            maxError = 0f;
            if (savedSlots == null || savedSlots.Count == 0) return false;
            object rootSplit = GetRootSplitView(GetCompositeHostWindow());
            if (rootSplit == null) return false;
            Rect rootScreen = GetViewScreenPosition(rootSplit);
            if (rootScreen.width <= 1f || rootScreen.height <= 1f) return false;

            foreach (CompositeSlotRequest savedSlot in savedSlots)
            {
                if (!TryGetNormalizedCompositeSlotRect(savedSlot, rootScreen, out Rect current))
                    return false;
                Rect expected = ClampCompositeRect(savedSlot.rect);
                maxError = Mathf.Max(maxError,
                    Mathf.Abs(current.x - expected.x),
                    Mathf.Abs(current.y - expected.y),
                    Mathf.Abs(current.width - expected.width),
                    Mathf.Abs(current.height - expected.height));
            }

            return maxError <= tolerance;
        }

        private static bool TryGetNormalizedCompositeSlotRect(
            CompositeSlotRequest savedSlot,
            Rect rootScreen,
            out Rect normalized)
        {
            normalized = Rect.zero;
            if (savedSlot == null || string.IsNullOrEmpty(savedSlot.slotId))
                return false;
            if (!TryGetCompositeSlot(savedSlot.slotId, out CompositeCaptureSlot slot) || slot?.Window == null)
                return false;
            object view = GetParentView(slot.Window);
            if (view == null) return false;
            Rect viewRect = GetViewScreenPosition(view);
            if (viewRect.width <= 1f || viewRect.height <= 1f) return false;
            normalized = NormalizeCompositeViewRect(viewRect, rootScreen);
            return true;
        }

        private static IEnumerable<object> GetViewChildren(object view)
        {
            if (view == null) yield break;
            PropertyInfo childrenProp = view.GetType().GetProperty("children",
                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            object childrenObj = childrenProp?.GetValue(view);
            if (!(childrenObj is System.Collections.IEnumerable children)) yield break;

            foreach (object child in children)
            {
                if (child != null) yield return child;
            }
        }

        private static void SetViewPosition(object view, Rect position)
        {
            if (view == null) return;
            PropertyInfo positionProp = view.GetType().GetProperty("position",
                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            positionProp?.SetValue(view, position);
        }

        private static void ReflowCompositeSplitRecursive(object view)
        {
            if (view == null) return;
            if (view.GetType().Name == "SplitView")
            {
                MethodInfo reflow = view.GetType().GetMethod("Reflow",
                    BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                reflow?.Invoke(view, null);
            }

            foreach (object child in GetViewChildren(view))
                ReflowCompositeSplitRecursive(child);
        }

        private static void RepaintCompositeViewRecursive(object view)
        {
            if (view == null) return;
            MethodInfo repaint = view.GetType().GetMethod("Repaint",
                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            repaint?.Invoke(view, null);

            foreach (object child in GetViewChildren(view))
                RepaintCompositeViewRecursive(child);
        }

        private static void ReleaseCompositeState()
        {
            CancelCompositeLayoutOperation();

            // Release each slot's SourceRT and close its EditorWindow.
            // EditorWindow.Close() removes the tab from the DockArea and, if it's
            // the last tab, closes the ContainerWindow through Unity's normal
            // destruction path (WM_CLOSE → DestroyWindow), which properly cleans
            // up D3D11 swap chains and RenderTextureMap entries.
            //
            // We do NOT call ContainerWindow.Close() directly via reflection.
            // That was introduced in commit 762d22a4 to prevent zombie HWNDs, but
            // it could destroy the MAIN editor's ContainerWindow when the slot's
            // EditorWindow was parented there — causing the editor to disappear.
            // Wrap in try-catch so one slot's failure doesn't block the rest.
            s_IsReleasingComposite = true;
            foreach (var slot in s_CompositeSlots.Values)
            {
                try
                {
                    ReleaseCompositeSlot(slot);
                }
                catch (Exception ex)
                {
                    CodelyLogger.LogError($"[NWB-Composite] ReleaseCompositeSlot failed for '{slot?.SlotId}': {ex.Message}");
                }
            }
            s_CompositeSlots.Clear();
            s_IsReleasingComposite = false;

            // Release global RenderTextures.
            if (RenderTexture.active == s_CompositeRT)
                RenderTexture.active = null;
            if (s_CompositeRT != null)
            {
                s_CompositeRT.Release();
                UnityEngine.Object.DestroyImmediate(s_CompositeRT);
                s_CompositeRT = null;
            }
            if (RenderTexture.active == s_CompositePaneDragRT)
                RenderTexture.active = null;
            if (s_CompositePaneDragRT != null)
            {
                s_CompositePaneDragRT.Release();
                UnityEngine.Object.DestroyImmediate(s_CompositePaneDragRT);
                s_CompositePaneDragRT = null;
            }
            if (s_CompositeReadbackTex != null)
            {
                UnityEngine.Object.DestroyImmediate(s_CompositeReadbackTex);
                s_CompositeReadbackTex = null;
            }
            s_CompositeActive = false;
            s_CompositeLogicalWidth = 0;
            s_CompositeLogicalHeight = 0;
            s_CompositeFrameBoundsLogical = Rect.zero;
            s_CompositeFrameOffsetPixels = Vector2.zero;
            s_CompositeFrameScalePixels = Vector2.one;
            s_CompositeWorkspaceReflowPending = false;
            s_CompositePlayModeInitDone = false;
            s_CompositeMouseCaptureView = null;
            s_CompositeMouseCaptureSlot = null;
            s_CompositeLastTabTarget = null;
            s_OffscreenTarget = null;
            s_OffscreenTargetType = null;
            s_CaptureRT = null;
        }
    }
}