using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnityEditor;
using UnityEditor.Callbacks;
using UnityEditor.UIElements;
using UnityEditorInternal;
using UnityEngine;
using UnityEngine.UIElements;

namespace AibisDream.FrameAnimation.Editor
{
    public sealed class FrameAnimationGraphEditorWindow : EditorWindow
    {
        private enum ResourceTab { Clips, Flows, Sources }
        private enum BottomTab { ImportDiff, Validation }
        private enum ValidationKindFilter { All, Graph, Clip, Flow, Source, Node, Edge }

        private const string LastGraphGuidKey = "AibisDream.FrameAnimation.Workspace.LastGraphGuid";

        [SerializeField] private FrameAnimationGraph graph;
        private ObjectField graphField;
        private ToolbarButton graphPropertiesButton;
        private ToolbarButton graphBreadcrumbButton;
        private Label dirtyLabel;
        private Label canvasLabel;
        private FrameAnimationGraphView graphView;
        private PopupField<string> flowFocusField;
        private string focusedFlowId = string.Empty;
        private IReadOnlyList<AnimationNode> multiSelectedNodes = Array.Empty<AnimationNode>();
        private AnimationNode lastSelectedNode;
        private Vector2 browserDragStart;
        private bool browserDragPending;
        private ListView resourceList;
        private readonly List<FrameAnimationBrowserEntry> browserEntries = new List<FrameAnimationBrowserEntry>();
        private ToolbarSearchField searchField;
        private EnumField filterField;
        private EnumField sortField;
        private VisualElement propertyContainer;
        private VisualElement bottomContainer;
        private VisualElement leftPanel;
        private VisualElement rightPanel;
        private VisualElement bottomPanel;
        private VisualElement globalToolbarHost;
        private VisualElement mainHost;
        private VisualElement bottomHost;
        private readonly List<ToolbarButton> resourceTabButtons = new List<ToolbarButton>();
        private readonly List<ToolbarButton> bottomTabButtons = new List<ToolbarButton>();
        private ResourceTab resourceTab;
        private BottomTab bottomTab;
        private FrameAnimationClipFilter clipFilter;
        private FrameAnimationClipSort clipSort;
        private FrameAnimationEditorSelection selection;
        private FrameAnimationImportPreview importPreview;
        private IReadOnlyList<FrameAnimationEditorIssue> validationIssues = Array.Empty<FrameAnimationEditorIssue>();
        private bool bottomCollapsed;
        private bool showErrors = true;
        private bool showWarnings = true;
        private bool showInfo = true;
        private ValidationKindFilter validationKindFilter;
        private double validateAt = -1d;
        private SerializedObject clipSerializedObject;
        private FrameClip frameListClip;
        private ReorderableList frameList;
        private bool frameListEditable;
        private readonly FrameAnimationPreviewCoordinator previewCoordinator = new FrameAnimationPreviewCoordinator();
        private readonly List<Slider> previewTimelineSliders = new List<Slider>();
        private readonly List<Label> previewTimeLabels = new List<Label>();
        private readonly List<Button> previewPlayButtons = new List<Button>();
        private readonly Dictionary<Button, Image> previewButtonImages = new Dictionary<Button, Image>();
        private static readonly HashSet<string> MissingPreviewIconWarnings = new HashSet<string>();
        private readonly List<Label> previewTargetLabels = new List<Label>();
        private VisualElement clipPreviewPanel;
        private FrameAnimationPreviewElement clipPreviewElement;
        private Label selectionPreviewTitle;
        private Label clipPreviewStatus;
        private EnumField previewBackgroundField;
        private EnumField previewZoomField;
        private Slider manualZoomSlider;
        private PopupField<string> previewSpeedField;
        private ToolbarButton bottomCollapseButton;
        private double lastPreviewTick;
        private bool updatingPreviewUi;

        [MenuItem(AibisEditorMenus.FrameAnimationGraphEditor)]
        public static void ShowWindow()
        {
            var window = GetWindow<FrameAnimationGraphEditorWindow>();
            window.titleContent = new GUIContent("Frame Animation Graph");
            window.minSize = new Vector2(1050f, 650f);
            if (window.graph == null)
            {
                window.RestoreLastGraph();
            }
            window.Show();
        }

        public static void Open(FrameAnimationGraph targetGraph)
        {
            ShowWindow();
            var window = GetWindow<FrameAnimationGraphEditorWindow>();
            window.SetGraph(targetGraph);
            window.Focus();
        }

        private void CreateGUI()
        {
            rootVisualElement.Clear();
            rootVisualElement.style.flexDirection = FlexDirection.Column;
            var visualTree = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(
                "Assets/Editor/FrameAnimation/FrameAnimationGraphEditor.uxml");
            if (visualTree != null)
            {
                visualTree.CloneTree(rootVisualElement);
            }
            else
            {
                var fallback = new VisualElement { name = "fa-workbench" };
                fallback.AddToClassList("fa-workbench");
                fallback.Add(globalToolbarHost = new VisualElement { name = "global-toolbar-host" });
                fallback.Add(mainHost = new VisualElement { name = "main-host" });
                fallback.Add(bottomHost = new VisualElement { name = "bottom-host" });
                rootVisualElement.Add(fallback);
            }
            var styleSheet = AssetDatabase.LoadAssetAtPath<StyleSheet>(
                "Assets/Editor/FrameAnimation/FrameAnimationGraphEditor.uss");
            if (styleSheet != null) rootVisualElement.styleSheets.Add(styleSheet);
            globalToolbarHost = rootVisualElement.Q<VisualElement>("global-toolbar-host");
            mainHost = rootVisualElement.Q<VisualElement>("main-host");
            bottomHost = rootVisualElement.Q<VisualElement>("bottom-host");
            resourceTabButtons.Clear();
            bottomTabButtons.Clear();
            previewCoordinator.Changed -= OnPreviewChanged;
            previewCoordinator.Changed += OnPreviewChanged;
            BuildToolbar();
            BuildMainArea();
            BuildBottomArea();
            RestoreLastGraph();
            SetGraph(graph);
            RestoreWorkspaceState();
            RestoreSelection();
            RefreshBrowser();
            RefreshFlowChoices();
            RefreshGraphView();
            UpdatePreviewTargetForSelection();
            RefreshPreviewUi();
        }

        private void OnEnable()
        {
            Undo.undoRedoPerformed += OnProjectDataChanged;
            EditorApplication.projectChanged += OnProjectDataChanged;
            lastPreviewTick = EditorApplication.timeSinceStartup;
        }

        private void OnDisable()
        {
            Undo.undoRedoPerformed -= OnProjectDataChanged;
            EditorApplication.projectChanged -= OnProjectDataChanged;
            previewCoordinator.Changed -= OnPreviewChanged;
            previewCoordinator.ClearTarget();
            SaveWorkspaceState();
        }

        private void Update()
        {
            var now = EditorApplication.timeSinceStartup;
            if (now - lastPreviewTick >= 1d / 30d)
            {
                var delta = Math.Max(0d, now - lastPreviewTick);
                lastPreviewTick = now;
                previewCoordinator.Tick(delta, graphView?.VisibleNodes ?? Array.Empty<AnimationNode>());
            }
            if (validateAt > 0d && EditorApplication.timeSinceStartup >= validateAt)
            {
                validateAt = -1d;
                validationIssues = FrameAnimationEditorValidationService.Validate(graph, false, out _);
                RefreshBottomPanel();
                RefreshBrowser();
                RefreshGraphView();
            }
            UpdateDirtyLabel();
        }

        private void BuildToolbar()
        {
            var toolbar = new Toolbar();
            toolbar.AddToClassList("fa-global-toolbar");
            graphField = new ObjectField("Graph")
            {
                objectType = typeof(FrameAnimationGraph),
                allowSceneObjects = false
            };
            graphField.style.width = 330f;
            graphField.RegisterValueChangedCallback(evt => SetGraph(evt.newValue as FrameAnimationGraph));
            toolbar.Add(graphField);
            graphPropertiesButton = new ToolbarButton(SelectGraphProperties)
            {
                name = "graph-properties-button",
                text = "Graph Properties",
                tooltip = "查看和编辑当前 Graph 的参数"
            };
            toolbar.Add(graphPropertiesButton);
            toolbar.Add(CreateToolbarSeparator());
            toolbar.Add(new ToolbarButton(CreateGraph) { text = "Create" });
            var saveButton = new ToolbarButton(SaveGraph) { text = "Save" };
            saveButton.AddToClassList("fa-button--primary");
            toolbar.Add(saveButton);
            dirtyLabel = new Label();
            dirtyLabel.style.marginLeft = 6f;
            toolbar.Add(dirtyLabel);
            toolbar.Add(new ToolbarSpacer { style = { flexGrow = 1f } });
            toolbar.Add(new ToolbarButton(PreviewAllImports) { text = "Preview Imports" });
            toolbar.Add(new ToolbarButton(RefreshAllImports) { text = "Refresh All" });
            toolbar.Add(new ToolbarButton(ValidateFull) { text = "Validate" });
            globalToolbarHost.Add(toolbar);
        }

        private void BuildMainArea()
        {
            var main = new VisualElement
            {
                style =
                {
                    flexDirection = FlexDirection.Row,
                    flexGrow = 1f,
                    overflow = Overflow.Hidden
                }
            };
            main.AddToClassList("fa-main");

            leftPanel = BuildLeftPanel();
            main.Add(leftPanel);
            main.Add(CreateVerticalResizer(leftPanel, 220f, 520f, "LeftWidth"));

            var canvas = new VisualElement
            {
                style =
                {
                    flexGrow = 1f,
                    minWidth = 280f,
                    flexDirection = FlexDirection.Column,
                    backgroundColor = new StyleColor(new Color(0.13f, 0.13f, 0.13f))
                }
            };
            canvas.AddToClassList("fa-canvas-panel");
            var canvasToolbar = new Toolbar { name = "canvas-toolbar" };
            canvasToolbar.AddToClassList("fa-canvas-toolbar");
            graphBreadcrumbButton = new ToolbarButton(SelectGraphProperties)
            {
                name = "graph-breadcrumb-button",
                text = "Graph",
                tooltip = "返回当前 Graph 的属性"
            };
            graphBreadcrumbButton.style.minWidth = 80f;
            graphBreadcrumbButton.style.maxWidth = 220f;
            canvasToolbar.Add(graphBreadcrumbButton);
            canvasToolbar.Add(CreateToolbarSeparator());
            var viewLabel = new Label("View");
            viewLabel.AddToClassList("fa-toolbar-label");
            canvasToolbar.Add(viewLabel);
            flowFocusField = new PopupField<string>(new List<string> { "All Flows" }, 0)
            {
                name = "flow-focus-field",
                style = { minWidth = 150f, maxWidth = 260f, flexShrink = 1f }
            };
            flowFocusField.RegisterValueChangedCallback(evt =>
            {
                if (evt.newValue == "All Flows")
                {
                    ExitFlowFocus(false);
                }
                else
                {
                    var flow = graph?.Flows.FirstOrDefault(item => item != null &&
                        FlowChoiceLabel(item) == evt.newValue);
                    EnterFlowFocus(flow?.Id);
                }
            });
            canvasToolbar.Add(flowFocusField);
            canvasToolbar.Add(new ToolbarSpacer { style = { flexGrow = 1f } });
            canvasToolbar.Add(new ToolbarButton(() => graphView?.FrameSelection())
            {
                text = "Frame Selection",
                tooltip = "Frame the current canvas selection"
            });
            var canvasActions = new ToolbarMenu { text = "Canvas" };
            canvasActions.menu.AppendAction("Frame All Visible", _ => graphView?.FrameAll());
            canvasActions.menu.AppendAction("Frame Current Flow", _ => graphView?.FrameCurrentFlow(focusedFlowId));
            canvasActions.menu.AppendAction("Auto Layout", _ => AutoLayoutCanvas());
            canvasActions.menu.AppendAction("Create Flow From Selection", _ => CreateFlowFromCanvasSelection());
            canvasActions.menu.AppendSeparator();
            canvasActions.menu.AppendAction("Node Preview/Static", _ => SetNodePreviewPolicy(NodePreviewPolicy.Static),
                _ => previewCoordinator.NodePolicy == NodePreviewPolicy.Static
                    ? DropdownMenuAction.Status.Checked : DropdownMenuAction.Status.Normal);
            canvasActions.menu.AppendAction("Node Preview/Selected Only", _ => SetNodePreviewPolicy(NodePreviewPolicy.SelectedOnly),
                _ => previewCoordinator.NodePolicy == NodePreviewPolicy.SelectedOnly
                    ? DropdownMenuAction.Status.Checked : DropdownMenuAction.Status.Normal);
            canvasActions.menu.AppendAction("Node Preview/All Visible", _ => SetNodePreviewPolicy(NodePreviewPolicy.AllVisible),
                _ => previewCoordinator.NodePolicy == NodePreviewPolicy.AllVisible
                    ? DropdownMenuAction.Status.Checked : DropdownMenuAction.Status.Normal);
            canvasToolbar.Add(canvasActions);
            canvas.Add(canvasToolbar);
            graphView = new FrameAnimationGraphView();
            graphView.SelectionRequested += value => SetSelection(value, false);
            graphView.MultiSelectionChanged += nodes =>
            {
                multiSelectedNodes = nodes ?? Array.Empty<AnimationNode>();
                RefreshInspector();
            };
            graphView.SelectionSetChanged += OnCanvasSelectionSetChanged;
            graphView.CreateFlowRequested += ShowCreateFlow;
            graphView.NodeCreated += _ => ExitFlowFocus(false);
            graphView.ExitFocusRequested += () => ExitFlowFocus(false);
            graphView.GraphChanged += OnCanvasGraphChanged;
            graphView.NotificationRequested += message => ShowNotification(new GUIContent(message));
            graphView.WorkspaceViewTransformChanged += (position, scale) =>
            {
                if (graph == null) return;
                FrameAnimationWorkspaceState.SetFloat(graph, "CanvasX", position.x);
                FrameAnimationWorkspaceState.SetFloat(graph, "CanvasY", position.y);
                FrameAnimationWorkspaceState.SetFloat(graph, "CanvasScale", scale);
            };
            canvas.Add(graphView);
            canvasLabel = new Label("选择或创建 FrameAnimationGraph")
            {
                pickingMode = PickingMode.Ignore,
                style =
                {
                    position = Position.Absolute,
                    left = 20f,
                    right = 20f,
                    top = 80f,
                    unityTextAlign = TextAnchor.MiddleCenter,
                    whiteSpace = WhiteSpace.Normal,
                    fontSize = 13f
                }
            };
            canvasLabel.AddToClassList("fa-empty-state");
            canvas.Add(canvasLabel);
            main.Add(canvas);

            rightPanel = new VisualElement
            {
                style =
                {
                    width = 338f,
                    minWidth = 260f,
                    maxWidth = 650f,
                    flexShrink = 0f,
                    flexDirection = FlexDirection.Column
                }
            };
            rightPanel.AddToClassList("fa-panel");
            rightPanel.Add(CreatePanelHeader("Properties"));
            clipPreviewPanel = BuildSelectionPreviewPanel();
            clipPreviewPanel.style.display = DisplayStyle.None;
            rightPanel.Add(clipPreviewPanel);
            propertyContainer = new ScrollView(ScrollViewMode.Vertical) { style = { flexGrow = 1f } };
            propertyContainer.AddToClassList("fa-inspector-scroll");
            rightPanel.Add(propertyContainer);
            main.Add(CreateVerticalResizer(rightPanel, 260f, 650f, "RightWidth", resizeFromLeft: true));
            main.Add(rightPanel);
            mainHost.Add(main);
        }

        private Toolbar BuildPreviewTransport()
        {
            var controls = new Toolbar { name = "preview-transport" };
            controls.AddToClassList("fa-preview-controls");
            controls.Add(CreatePreviewButton("preview-restart", previewCoordinator.Restart, "Restart",
                "d_Refresh", "Refresh"));
            controls.Add(CreatePreviewButton("preview-previous-frame", () => previewCoordinator.Step(-1),
                "Previous Frame", "Animation.PrevKey"));
            var play = CreatePreviewButton("preview-play-pause", PreviewPlayPause, "Play", "PlayButton");
            previewPlayButtons.Add(play);
            controls.Add(play);
            controls.Add(CreatePreviewButton("preview-next-frame", () => previewCoordinator.Step(1),
                "Next Frame", "Animation.NextKey"));
            controls.Add(CreatePreviewButton("preview-stop", previewCoordinator.Stop, "Stop",
                "Assets/Editor/FrameAnimation/Icons/PreviewStop.png"));

            var timeline = new Slider(0f, 1f)
            {
                name = "preview-timeline"
            };
            timeline.AddToClassList("fa-preview-timeline");
            timeline.RegisterValueChangedCallback(evt =>
            {
                if (!updatingPreviewUi) previewCoordinator.Seek(evt.newValue);
            });
            previewTimelineSliders.Add(timeline);
            controls.Add(timeline);
            var time = new Label("0 / 0 ms") { name = "preview-time" };
            time.AddToClassList("fa-preview-time");
            previewTimeLabels.Add(time);
            controls.Add(time);
            return controls;
        }

        private ToolbarButton CreatePreviewButton(
            string name,
            Action action,
            string tooltip,
            params string[] iconSources)
        {
            var button = new ToolbarButton(action) { name = name, tooltip = tooltip };
            button.AddToClassList("fa-preview-button");
            var image = new Image { pickingMode = PickingMode.Ignore };
            image.AddToClassList("fa-preview-button__icon");
            button.Add(image);
            previewButtonImages[button] = image;
            SetPreviewButtonIcon(button, tooltip, iconSources);
            return button;
        }

        private void SetPreviewButtonIcon(Button button, string tooltip, params string[] iconSources)
        {
            button.tooltip = tooltip;
            if (!previewButtonImages.TryGetValue(button, out var image)) return;
            image.image = null;
            foreach (var iconSource in iconSources)
            {
                var icon = iconSource.StartsWith("Assets/", StringComparison.Ordinal)
                    ? AssetDatabase.LoadAssetAtPath<Texture2D>(iconSource)
                    : EditorGUIUtility.IconContent(iconSource)?.image;
                if (icon == null) continue;
                image.image = icon;
                return;
            }
            if (MissingPreviewIconWarnings.Add(tooltip))
            {
                var attempted = iconSources.Length > 0 ? $" Tried: {string.Join(", ", iconSources)}." : string.Empty;
                Debug.LogWarning($"Frame Animation Preview: no reliable Unity editor icon is available for " +
                                 $"'{tooltip}'.{attempted}");
            }
        }

        private VisualElement BuildSelectionPreviewPanel()
        {
            var panel = new VisualElement { name = "selection-preview-panel" };
            panel.AddToClassList("fa-clip-preview-panel");
            panel.AddToClassList("fa-selection-preview-panel");
            var header = new VisualElement();
            header.AddToClassList("fa-selection-preview-header");
            selectionPreviewTitle = new Label("Selection Preview");
            selectionPreviewTitle.name = "selection-preview-title";
            selectionPreviewTitle.AddToClassList("fa-selection-preview-title");
            header.Add(selectionPreviewTitle);
            var targetLabel = new Label("Preview: None");
            targetLabel.AddToClassList("fa-selection-preview-target");
            previewTargetLabels.Add(targetLabel);
            header.Add(targetLabel);
            panel.Add(header);
            clipPreviewElement = new FrameAnimationPreviewElement { name = "selection-preview-element" };
            panel.Add(clipPreviewElement);
            panel.Add(BuildPreviewTransport());
            var settingsRow = new VisualElement();
            settingsRow.AddToClassList("fa-preview-settings");
            previewSpeedField = new PopupField<string>(
                new List<string> { "0.25×", "0.5×", "1×", "2×", "4×" }, "1×");
            previewSpeedField.RegisterValueChangedCallback(evt =>
            {
                previewCoordinator.PreviewSpeed = ParsePreviewSpeed(evt.newValue);
                SaveWorkspaceState();
            });
            settingsRow.Add(CreatePreviewSetting("Speed", previewSpeedField));
            previewBackgroundField = new EnumField(FrameAnimationPreviewBackground.Checkerboard);
            previewBackgroundField.RegisterValueChangedCallback(evt =>
            {
                previewCoordinator.Background = (FrameAnimationPreviewBackground)evt.newValue;
                SaveWorkspaceState();
                RefreshPreviewUi();
            });
            settingsRow.Add(CreatePreviewSetting("Background", previewBackgroundField));
            panel.Add(settingsRow);
            var zoomRow = new VisualElement();
            zoomRow.AddToClassList("fa-preview-settings");
            previewZoomField = new EnumField(FrameAnimationPreviewZoomMode.Fit);
            previewZoomField.RegisterValueChangedCallback(evt =>
            {
                previewCoordinator.ZoomMode = (FrameAnimationPreviewZoomMode)evt.newValue;
                SaveWorkspaceState();
                RefreshPreviewUi();
            });
            zoomRow.Add(CreatePreviewSetting("Zoom", previewZoomField));
            manualZoomSlider = new Slider("Manual", 0.25f, 8f) { style = { flexGrow = 1f } };
            manualZoomSlider.RegisterValueChangedCallback(evt =>
            {
                previewCoordinator.ManualZoom = evt.newValue;
                SaveWorkspaceState();
                RefreshPreviewUi();
            });
            zoomRow.Add(manualZoomSlider);
            panel.Add(zoomRow);
            clipPreviewStatus = new Label();
            clipPreviewStatus.AddToClassList("fa-preview-status");
            panel.Add(clipPreviewStatus);
            return panel;
        }

        private static VisualElement CreatePreviewSetting(string labelText, VisualElement field)
        {
            var setting = new VisualElement();
            setting.AddToClassList("fa-preview-setting");
            setting.Add(new Label(labelText));
            field.AddToClassList("fa-preview-setting__field");
            setting.Add(field);
            return setting;
        }

        private void SetNodePreviewPolicy(NodePreviewPolicy policy)
        {
            previewCoordinator.SetNodePolicy(policy);
            SaveWorkspaceState();
            RefreshPreviewUi();
        }

        private void PreviewPlayPause()
        {
            if (previewCoordinator.State == FrameAnimationPreviewState.Playing)
            {
                previewCoordinator.Pause();
                return;
            }
            if (previewCoordinator.TargetKind == FrameAnimationPreviewTargetKind.Flow)
            {
                validationIssues = FrameAnimationEditorValidationService.Validate(graph, false, out _);
                RefreshBrowser();
                RefreshBottomPanel();
                RefreshGraphView();
            }
            previewCoordinator.Play();
            if (previewCoordinator.State == FrameAnimationPreviewState.Failed)
            {
                ShowNotification(new GUIContent(previewCoordinator.Error.Message));
            }
        }

        private void UpdatePreviewTargetForSelection()
        {
            if (graph == null)
            {
                previewCoordinator.ClearTarget();
                return;
            }
            if (previewCoordinator.TargetKind == FrameAnimationPreviewTargetKind.Flow &&
                previewCoordinator.Target is AnimationFlow activeFlow &&
                IsSelectionInsideFlow(activeFlow, selection))
            {
                RefreshPreviewUi();
                return;
            }
            switch (selection.Kind)
            {
                case FrameAnimationEditorSelectionKind.Clip:
                    previewCoordinator.SetTarget(FrameAnimationPreviewTargetKind.Clip, selection.Value);
                    break;
                case FrameAnimationEditorSelectionKind.Node:
                    previewCoordinator.SetTarget(FrameAnimationPreviewTargetKind.Node, selection.Value);
                    break;
                case FrameAnimationEditorSelectionKind.Flow:
                    previewCoordinator.SetTarget(FrameAnimationPreviewTargetKind.Flow, selection.Value);
                    break;
                default:
                    previewCoordinator.ClearTarget();
                    break;
            }
        }

        private bool IsSelectionInsideFlow(AnimationFlow flow, FrameAnimationEditorSelection value)
        {
            if (flow == null || graph == null) return false;
            if (value.Kind == FrameAnimationEditorSelectionKind.Flow) return ReferenceEquals(value.Value, flow);
            var reachable = new FrameAnimationGraphTopology(graph).GetReachable(flow.EntryNodeId);
            return value.Value switch
            {
                AnimationNode node => reachable.Nodes.Contains(node),
                AnimationEdge edge => reachable.Edges.Contains(edge),
                _ => false
            };
        }

        private void OnPreviewChanged()
        {
            RefreshPreviewUi();
            Repaint();
        }

        private void RefreshPreviewUi()
        {
            if (rootVisualElement == null) return;
            updatingPreviewUi = true;
            var timeline = previewCoordinator.Timeline;
            var maximum = timeline?.DisplayDurationSeconds ?? 0d;
            var position = Math.Min(maximum, previewCoordinator.PositionSeconds);
            foreach (var slider in previewTimelineSliders)
            {
                slider.lowValue = 0f;
                slider.highValue = Mathf.Max(0.0001f, (float)maximum);
                slider.SetValueWithoutNotify((float)position);
                slider.SetEnabled(timeline != null && timeline.Segments.Count > 0 && maximum > 0d);
            }
            var total = timeline?.IsInfinite == true ? "∞" : FormatPreviewTime(maximum);
            foreach (var label in previewTimeLabels)
            {
                label.text = $"{FormatPreviewTime(position)} / {total}";
            }
            foreach (var button in previewPlayButtons)
            {
                var isPlaying = previewCoordinator.State == FrameAnimationPreviewState.Playing;
                SetPreviewButtonIcon(button, isPlaying ? "Pause" : "Play",
                    isPlaying ? "PauseButton" : "PlayButton");
                button.SetEnabled(previewCoordinator.TargetKind != FrameAnimationPreviewTargetKind.None);
            }
            var targetText = PreviewTargetName();
            foreach (var label in previewTargetLabels)
            {
                label.text = targetText;
                label.tooltip = targetText;
            }

            if (clipPreviewPanel != null)
            {
                clipPreviewPanel.style.display = previewCoordinator.TargetKind != FrameAnimationPreviewTargetKind.None &&
                                                 previewCoordinator.Target != null
                    ? DisplayStyle.Flex : DisplayStyle.None;
            }
            if (selectionPreviewTitle != null)
            {
                selectionPreviewTitle.text = previewCoordinator.TargetKind switch
                {
                    FrameAnimationPreviewTargetKind.Clip => "Clip Preview",
                    FrameAnimationPreviewTargetKind.Node => "Node Preview",
                    FrameAnimationPreviewTargetKind.Flow => "Flow Preview",
                    _ => "Selection Preview"
                };
            }
            if (clipPreviewElement != null)
            {
                clipPreviewElement.SetBackground(previewCoordinator.Background);
                clipPreviewElement.SetZoom(previewCoordinator.ZoomMode, previewCoordinator.ManualZoom);
                clipPreviewElement.SetDisplay(
                    previewCoordinator.CurrentSprite,
                    previewCoordinator.CurrentSprite == null,
                    previewCoordinator.Snapshot.IsCompleted ? previewCoordinator.Snapshot.EndBehavior.ToString() : "Empty Frame");
            }
            if (clipPreviewStatus != null)
            {
                clipPreviewStatus.text = BuildPreviewStatus();
            }
            if (manualZoomSlider != null)
            {
                manualZoomSlider.SetValueWithoutNotify(previewCoordinator.ManualZoom);
                manualZoomSlider.SetEnabled(previewCoordinator.ZoomMode == FrameAnimationPreviewZoomMode.Manual);
            }
            previewZoomField?.SetValueWithoutNotify(previewCoordinator.ZoomMode);
            previewBackgroundField?.SetValueWithoutNotify(previewCoordinator.Background);
            previewSpeedField?.SetValueWithoutNotify(FormatPreviewSpeed(previewCoordinator.PreviewSpeed));
            graphView?.ApplyPreview(previewCoordinator);
            updatingPreviewUi = false;
        }

        private string BuildPreviewStatus()
        {
            if (previewCoordinator.State == FrameAnimationPreviewState.Failed)
            {
                return $"ERROR [{previewCoordinator.Error.Code}] {previewCoordinator.Error.Message}";
            }
            var snapshot = previewCoordinator.Snapshot;
            if (!snapshot.HasStarted || snapshot.Clip == null) return "No preview target";
            var duration = snapshot.FrameIndex >= 0 && snapshot.FrameIndex < snapshot.Clip.FrameCount
                ? snapshot.Clip.Frames[snapshot.FrameIndex].DurationMs : 0;
            var effective = snapshot.StepSpeed > 0f ? duration / snapshot.StepSpeed : double.PositiveInfinity;
            return $"{previewCoordinator.State} · Frame {snapshot.FrameIndex + 1}/{snapshot.Clip.FrameCount} · " +
                   $"source {duration} ms · effective {(double.IsInfinity(effective) ? "∞" : effective.ToString("0") + " ms")} · {snapshot.Clip.Id}" +
                   (string.IsNullOrEmpty(snapshot.NodeId) ? string.Empty : $" · Node {snapshot.NodeId}") +
                   (previewCoordinator.Timeline?.IsBlocked == true ? " · Blocked (speed 0)" : string.Empty);
        }

        private string PreviewTargetName()
        {
            return previewCoordinator.Target switch
            {
                FrameClip clip => $"Clip: {clip.DisplayName}",
                AnimationNode node => $"Node: {node.DisplayName}",
                AnimationFlow flow => $"Flow: {flow.DisplayName}",
                _ => "Preview: None"
            };
        }

        private string BuildFlowPreviewTargetName(AnimationFlow flow)
        {
            var snapshot = previewCoordinator.Snapshot;
            if (!snapshot.HasStarted || snapshot.Clip == null) return $"Flow: {flow.DisplayName}";
            var node = graph?.Nodes.FirstOrDefault(item => item != null && item.InternalId == snapshot.NodeId);
            var ending = snapshot.IsCompleted && previewCoordinator.CurrentSprite == null
                ? $" · {snapshot.EndBehavior}" : string.Empty;
            var blocked = previewCoordinator.Timeline?.IsBlocked == true ? " · Blocked" : string.Empty;
            return $"Flow: {flow.DisplayName} · Node: {node?.DisplayName ?? snapshot.NodeId} · " +
                   $"{snapshot.Clip.Id} F{snapshot.FrameIndex + 1}/{snapshot.Clip.FrameCount}{ending}{blocked}";
        }

        private static string FormatPreviewTime(double seconds) => $"{Math.Max(0d, seconds) * 1000d:0} ms";

        private static float ParsePreviewSpeed(string value)
        {
            return value switch { "0.25×" => 0.25f, "0.5×" => 0.5f, "2×" => 2f, "4×" => 4f, _ => 1f };
        }

        private static string FormatPreviewSpeed(float value)
        {
            if (Mathf.Approximately(value, 0.25f)) return "0.25×";
            if (Mathf.Approximately(value, 0.5f)) return "0.5×";
            if (Mathf.Approximately(value, 2f)) return "2×";
            if (Mathf.Approximately(value, 4f)) return "4×";
            return "1×";
        }

        private VisualElement BuildLeftPanel()
        {
            var panel = new VisualElement
            {
                style =
                {
                    width = 286f,
                    minWidth = 220f,
                    maxWidth = 520f,
                    flexShrink = 0f,
                    flexDirection = FlexDirection.Column
                }
            };
            panel.AddToClassList("fa-panel");
            var tabs = new Toolbar();
            tabs.AddToClassList("fa-resource-tabs");
            AddResourceTab(tabs, ResourceTab.Clips, "Clips");
            AddResourceTab(tabs, ResourceTab.Flows, "Flows");
            AddResourceTab(tabs, ResourceTab.Sources, "Sources");
            panel.Add(tabs);
            var tools = new VisualElement();
            tools.AddToClassList("fa-resource-tools");
            searchField = new ToolbarSearchField();
            searchField.RegisterValueChangedCallback(_ =>
            {
                SaveWorkspaceState();
                RefreshBrowser();
            });
            tools.Add(searchField);
            var controls = new VisualElement { style = { flexDirection = FlexDirection.Row } };
            filterField = new EnumField(FrameAnimationClipFilter.All) { style = { flexGrow = 1f } };
            filterField.RegisterValueChangedCallback(evt =>
            {
                clipFilter = (FrameAnimationClipFilter)evt.newValue;
                SaveWorkspaceState();
                RefreshBrowser();
            });
            sortField = new EnumField(FrameAnimationClipSort.Name) { style = { flexGrow = 1f } };
            sortField.RegisterValueChangedCallback(evt =>
            {
                clipSort = (FrameAnimationClipSort)evt.newValue;
                SaveWorkspaceState();
                RefreshBrowser();
            });
            controls.Add(filterField);
            controls.Add(sortField);
            tools.Add(controls);
            panel.Add(tools);

            resourceList = new ListView(browserEntries, 48f, MakeBrowserItem, BindBrowserItem)
            {
                selectionType = SelectionType.Single,
                virtualizationMethod = CollectionVirtualizationMethod.DynamicHeight,
                style = { flexGrow = 1f }
            };
            resourceList.AddToClassList("fa-resource-list");
            resourceList.selectionChanged += OnBrowserSelectionChanged;
            resourceList.itemsChosen += chosen =>
            {
                var entry = chosen.Cast<FrameAnimationBrowserEntry>().FirstOrDefault(item => !item.IsHeader);
                if (entry != null)
                {
                    SetSelection(entry.Selection);
                }
            };
            panel.Add(resourceList);

            var actions = new VisualElement { style = { flexDirection = FlexDirection.Row } };
            actions.AddToClassList("fa-resource-actions");
            actions.Add(new Button(CreateManualClip) { text = "New Manual" });
            actions.Add(new Button(AddExistingClip) { text = "Add Existing" });
            actions.Add(new Button(AddSource) { text = "Add Source" });
            panel.Add(actions);
            return panel;
        }

        private void BuildBottomArea()
        {
            bottomPanel = new VisualElement
            {
                style =
                {
                    height = 210f,
                    minHeight = 28f,
                    maxHeight = 520f,
                    flexShrink = 0f,
                    borderTopWidth = 1f,
                    borderTopColor = new StyleColor(Color.black)
                }
            };
            bottomPanel.AddToClassList("fa-bottom-panel");
            var toolbar = new Toolbar();
            toolbar.AddToClassList("fa-bottom-toolbar");
            var tabs = new VisualElement();
            tabs.AddToClassList("fa-bottom-tabs");
            AddBottomTab(tabs, BottomTab.ImportDiff, "Import Diff");
            AddBottomTab(tabs, BottomTab.Validation, "Validation");
            toolbar.Add(tabs);
            toolbar.Add(new ToolbarSpacer { style = { flexGrow = 1f } });
            bottomCollapseButton = new ToolbarButton(ToggleBottom)
            {
                name = "bottom-collapse-button",
                text = "▾",
                tooltip = "Collapse results"
            };
            bottomCollapseButton.AddToClassList("fa-bottom-collapse");
            toolbar.Add(bottomCollapseButton);
            bottomPanel.Add(toolbar);
            bottomContainer = new ScrollView(ScrollViewMode.Vertical) { style = { flexGrow = 1f } };
            bottomContainer.AddToClassList("fa-bottom-scroll");
            bottomPanel.Add(bottomContainer);
            var resizer = CreateHorizontalResizer(bottomPanel, 120f, 520f, "BottomHeight");
            bottomHost.Add(resizer);
            bottomHost.Add(bottomPanel);
        }

        private static VisualElement CreatePanelHeader(string text)
        {
            var label = new Label(text);
            label.AddToClassList("fa-panel-header");
            return label;
        }

        private static VisualElement CreateToolbarSeparator()
        {
            var separator = new VisualElement();
            separator.AddToClassList("fa-toolbar-separator");
            return separator;
        }

        private void AddResourceTab(Toolbar toolbar, ResourceTab tab, string text)
        {
            var button = new ToolbarButton(() => SetResourceTab(tab, true))
            {
                name = $"resource-tab-{tab.ToString().ToLowerInvariant()}",
                text = text,
                userData = tab
            };
            resourceTabButtons.Add(button);
            toolbar.Add(button);
        }

        private void AddBottomTab(VisualElement toolbar, BottomTab tab, string text)
        {
            var button = new ToolbarButton(() => SetBottomTab(tab))
            {
                name = tab == BottomTab.ImportDiff ? "bottom-tab-import-diff" : "bottom-tab-validation",
                text = text,
                userData = tab
            };
            button.AddToClassList("fa-bottom-tab");
            bottomTabButtons.Add(button);
            toolbar.Add(button);
        }

        private void RefreshTabStyles()
        {
            foreach (var button in resourceTabButtons)
            {
                button.EnableInClassList("fa-tab--active", button.userData is ResourceTab tab && tab == resourceTab);
            }
            foreach (var button in bottomTabButtons)
            {
                if (!(button.userData is BottomTab tab)) continue;
                button.EnableInClassList("fa-tab--active", tab == bottomTab);
                var count = tab == BottomTab.Validation ? validationIssues.Count : ImportDiffCount();
                var label = tab == BottomTab.Validation ? "Validation" : "Import Diff";
                button.text = count > 0 ? $"{label}  {count}" : label;
            }
        }

        private int ImportDiffCount()
        {
            return importPreview?.Sources.Sum(source =>
                source.Issues.Count + source.ClipDiffs.Count + source.SpriteDiffs.Count) ?? 0;
        }

        private static bool SelectionMatches(
            FrameAnimationEditorSelection first,
            FrameAnimationEditorSelection second) =>
            first.Kind == second.Kind && ReferenceEquals(first.Value, second.Value);

        private VisualElement MakeBrowserItem()
        {
            var row = new FrameAnimationResourceRowElement();
            row.RegisterCallback<PointerDownEvent>(evt =>
            {
                if (evt.button == 0 && row.userData is FrameAnimationBrowserEntry entry &&
                    entry.Selection.Kind == FrameAnimationEditorSelectionKind.Clip && !entry.IsHeader)
                {
                    browserDragPending = true;
                    browserDragStart = evt.position;
                }
            });
            row.RegisterCallback<PointerMoveEvent>(evt =>
            {
                if (!browserDragPending || Vector2.Distance(browserDragStart, evt.position) < 5f ||
                    !(row.userData is FrameAnimationBrowserEntry entry) || !(entry.Selection.Value is FrameClip clip))
                {
                    return;
                }
                browserDragPending = false;
                DragAndDrop.PrepareStartDrag();
                DragAndDrop.SetGenericData(FrameAnimationGraphView.ClipDragKey, clip);
                DragAndDrop.objectReferences = new UnityEngine.Object[] { clip };
                DragAndDrop.StartDrag($"Create Node: {clip.Id}");
            });
            row.RegisterCallback<PointerUpEvent>(_ => browserDragPending = false);
            return row;
        }

        private void BindBrowserItem(VisualElement element, int index)
        {
            var row = (FrameAnimationResourceRowElement)element;
            if (index < 0 || index >= browserEntries.Count)
            {
                row.Bind(null, false);
                return;
            }
            var entry = browserEntries[index];
            row.Bind(entry, SelectionMatches(entry.Selection, selection));
        }

        private void OnBrowserSelectionChanged(IEnumerable<object> values)
        {
            var entry = values.Cast<FrameAnimationBrowserEntry>().FirstOrDefault();
            if (entry != null && !entry.IsHeader)
            {
                SetSelection(entry.Selection);
            }
        }

        private void SetGraph(FrameAnimationGraph value)
        {
            if (graph == value && graphField != null)
            {
                graphField.SetValueWithoutNotify(graph);
            }
            else
            {
                SaveGraph();
                SaveWorkspaceState();
                focusedFlowId = string.Empty;
                graph = value;
                previewCoordinator.SetGraph(graph);
                selection = graph != null
                    ? new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Graph, graph)
                    : default;
                importPreview = null;
                validationIssues = Array.Empty<FrameAnimationEditorIssue>();
                multiSelectedNodes = Array.Empty<AnimationNode>();
                lastSelectedNode = null;
                frameListClip = null;
                frameList = null;
                clipSerializedObject = null;
                RestoreWorkspaceState();
                RestoreSelection();
                if (graph != null && FrameAnimationGraphMutationService.EnsureEditorData(graph))
                {
                    ShowNotification(new GUIContent("已初始化缺失的节点布局数据，可使用 Undo 撤销。"));
                }
            }

            previewCoordinator.SetGraph(graph);
            graphField?.SetValueWithoutNotify(graph);
            if (graph != null)
            {
                var path = AssetDatabase.GetAssetPath(graph);
                EditorPrefs.SetString(LastGraphGuidKey, AssetDatabase.AssetPathToGUID(path));
            }
            RefreshBrowser();
            RefreshFlowChoices();
            RefreshGraphView();
            RestoreCanvasView();
            RefreshCanvasSummary();
            UpdatePreviewTargetForSelection();
            RefreshInspector();
            RefreshBottomPanel();
        }

        private void RestoreLastGraph()
        {
            if (graph != null)
            {
                return;
            }
            var guid = EditorPrefs.GetString(LastGraphGuidKey, string.Empty);
            if (!string.IsNullOrEmpty(guid))
            {
                graph = AssetDatabase.LoadAssetAtPath<FrameAnimationGraph>(AssetDatabase.GUIDToAssetPath(guid));
            }
        }

        private void SetResourceTab(ResourceTab tab, bool userInitiated = false)
        {
            if (userInitiated && tab != ResourceTab.Flows)
            {
                ExitFlowFocus(false);
            }
            resourceTab = tab;
            SaveWorkspaceState();
            RefreshBrowser();
            RefreshTabStyles();
        }

        private void SetBottomTab(BottomTab tab)
        {
            bottomTab = tab;
            bottomCollapsed = false;
            ApplyBottomState();
            SaveWorkspaceState();
            RefreshTabStyles();
            RefreshBottomPanel();
        }

        private void SetSelection(FrameAnimationEditorSelection value, bool locateOnCanvas = true)
        {
            if (value.Kind == FrameAnimationEditorSelectionKind.Flow && value.Value is AnimationFlow selectedFlow)
            {
                EnterFlowFocus(selectedFlow.Id);
            }
            else if (FrameAnimationFlowFocusPolicy.ShouldExitForSelection(graph, focusedFlowId, value))
            {
                ExitFlowFocus(false);
            }
            selection = value;
            if (value.Kind == FrameAnimationEditorSelectionKind.Node && value.Value is AnimationNode node)
            {
                lastSelectedNode = node;
            }
            frameListClip = null;
            frameList = null;
            clipSerializedObject = null;
            RefreshInspector();
            resourceList?.RefreshItems();
            RefreshCanvasSummary();
            SaveWorkspaceState();
            UpdatePreviewTargetForSelection();
            if (locateOnCanvas && (value.Kind == FrameAnimationEditorSelectionKind.Node ||
                                   value.Kind == FrameAnimationEditorSelectionKind.Edge))
            {
                graphView?.SelectAndFrame(value);
            }
        }

        private void SelectGraphProperties()
        {
            if (graph == null)
            {
                return;
            }

            graphView?.ClearSelection();
            resourceList?.ClearSelection();
            multiSelectedNodes = Array.Empty<AnimationNode>();
            lastSelectedNode = null;
            SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Graph, graph), false);
        }

        private void RefreshBrowser()
        {
            if (resourceList == null)
            {
                return;
            }
            browserEntries.Clear();
            if (graph != null)
            {
                switch (resourceTab)
                {
                    case ResourceTab.Clips:
                        BuildClipEntries();
                        break;
                    case ResourceTab.Flows:
                        BuildFlowEntries();
                        break;
                    case ResourceTab.Sources:
                        BuildSourceEntries();
                        break;
                }
            }
            filterField.style.display = resourceTab == ResourceTab.Clips ? DisplayStyle.Flex : DisplayStyle.None;
            sortField.style.display = resourceTab == ResourceTab.Clips ? DisplayStyle.Flex : DisplayStyle.None;
            resourceList.Rebuild();
            RefreshTabStyles();
        }

        private void BuildClipEntries()
        {
            var clips = FrameAnimationResourceQuery.QueryClips(
                graph, searchField?.value, clipFilter, clipSort);
            var grouped = string.IsNullOrWhiteSpace(searchField?.value) && clipSort == FrameAnimationClipSort.Source;
            if (!grouped)
            {
                foreach (var clip in clips)
                {
                    AddClipEntry(clip);
                }
                return;
            }

            var sources = graph.ImportSources.Where(source => source != null)
                .GroupBy(source => source.InternalId ?? string.Empty)
                .ToDictionary(group => group.Key, group => group.First().DisplayName);
            foreach (var group in clips.GroupBy(clip => FrameAnimationResourceQuery.SourceName(clip, sources)))
            {
                browserEntries.Add(new FrameAnimationBrowserEntry
                {
                    Kind = FrameAnimationBrowserEntryKind.Header,
                    Title = group.Key
                });
                foreach (var clip in group)
                {
                    AddClipEntry(clip);
                }
            }
        }

        private void AddClipEntry(FrameClip clip)
        {
            var source = clip.IsImported
                ? FrameAnimationResourceQuery.SourceName(clip,
                    graph.ImportSources.Where(item => item != null)
                        .GroupBy(item => item.InternalId ?? string.Empty)
                        .ToDictionary(group => group.Key, group => group.First().DisplayName)) + "/" +
                  clip.ImportInfo.SourceTagName
                : "Manual";
            var refs = FrameAnimationResourceQuery.ReferenceCount(graph, clip);
            var issueState = GetIssueState(FrameAnimationEditorSelectionKind.Clip, clip);
            var missing = clip.IsImported && clip.ImportInfo.IsMissingFromSource;
            browserEntries.Add(new FrameAnimationBrowserEntry
            {
                Kind = FrameAnimationBrowserEntryKind.Clip,
                Title = clip.DisplayName,
                Id = clip.Id,
                TypeLabel = clip.IsImported ? "IMPORTED" : "MANUAL",
                Meta = $"{clip.FrameCount} frames  ·  {clip.TotalDurationMs} ms  ·  {source}  ·  refs {refs}",
                StatusLabel = missing ? "MISSING" : issueState == FrameAnimationBrowserIssueState.Error
                    ? "ERROR" : issueState == FrameAnimationBrowserIssueState.Warning ? "WARNING" : string.Empty,
                IssueState = missing && issueState == FrameAnimationBrowserIssueState.None
                    ? FrameAnimationBrowserIssueState.Warning : issueState,
                Selection = new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Clip, clip)
            });
        }

        private void BuildFlowEntries()
        {
            var search = searchField?.value;
            foreach (var flow in graph.Flows.Where(flow => flow != null &&
                         (string.IsNullOrWhiteSpace(search) || Contains(flow.Id, search) || Contains(flow.DisplayName, search)))
                     .OrderBy(flow => flow.DisplayName, StringComparer.Ordinal).ThenBy(flow => flow.Id, StringComparer.Ordinal))
            {
                var issueState = GetIssueState(FrameAnimationEditorSelectionKind.Flow, flow);
                browserEntries.Add(new FrameAnimationBrowserEntry
                {
                    Kind = FrameAnimationBrowserEntryKind.Flow,
                    Title = flow.DisplayName,
                    Id = flow.Id,
                    TypeLabel = "FLOW",
                    Meta = $"entry  {flow.EntryNodeId}",
                    StatusLabel = issueState == FrameAnimationBrowserIssueState.Error
                        ? "ERROR" : issueState == FrameAnimationBrowserIssueState.Warning ? "WARNING" : string.Empty,
                    AccentColor = FrameAnimationFlowColorUtility.ResolveRaw(graph, flow),
                    IssueState = issueState,
                    Selection = new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Flow, flow)
                });
            }
        }

        private void BuildSourceEntries()
        {
            var search = searchField?.value;
            foreach (var source in graph.ImportSources.Where(source => source != null &&
                         (string.IsNullOrWhiteSpace(search) || Contains(source.DisplayName, search) || Contains(source.InternalId, search)))
                     .OrderBy(source => source.DisplayName, StringComparer.Ordinal)
                     .ThenBy(source => source.InternalId, StringComparer.Ordinal))
            {
                var count = graph.Clips.Count(clip => clip != null && clip.ImportInfo?.ImportSourceId == source.InternalId);
                var issueState = GetIssueState(FrameAnimationEditorSelectionKind.Source, source);
                browserEntries.Add(new FrameAnimationBrowserEntry
                {
                    Kind = FrameAnimationBrowserEntryKind.Source,
                    Title = source.DisplayName,
                    Id = source.InternalId,
                    TypeLabel = "SOURCE",
                    Meta = $"{count} clips  ·  {(source.IsEnabled ? "Enabled" : "Disabled")}  ·  {(source.ManageSpriteSlicing ? "Writable" : "Read Only")}",
                    StatusLabel = issueState == FrameAnimationBrowserIssueState.Error
                        ? "ERROR" : issueState == FrameAnimationBrowserIssueState.Warning ? "WARNING" : string.Empty,
                    IssueState = issueState,
                    Selection = new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Source, source)
                });
            }
        }

        private static bool Contains(string value, string search) =>
            !string.IsNullOrEmpty(value) && value.IndexOf(search, StringComparison.OrdinalIgnoreCase) >= 0;

        private void RefreshGraphView()
        {
            graphView?.Bind(graph, validationIssues, focusedFlowId);
            graphView?.ApplyPreview(previewCoordinator);
        }

        private void OnCanvasGraphChanged()
        {
            previewCoordinator.RefreshTarget(true);
            RevalidateFlowFocus();
            ScheduleLightValidation();
            RefreshBrowser();
            RefreshFlowChoices();
            RefreshCanvasSummary();
            RefreshInspector();
            EditorApplication.delayCall += () =>
            {
                if (this != null)
                {
                    RefreshGraphView();
                }
            };
        }

        private static string FlowChoiceLabel(AnimationFlow flow) => $"{flow.DisplayName} ({flow.Id})";

        private void RefreshFlowChoices()
        {
            if (flowFocusField != null)
            {
                var choices = new List<string> { "All Flows" };
                if (graph != null)
                {
                    choices.AddRange(graph.Flows.Where(flow => flow != null)
                        .OrderBy(flow => flow.DisplayName, StringComparer.Ordinal)
                        .ThenBy(flow => flow.Id, StringComparer.Ordinal)
                        .Select(FlowChoiceLabel));
                }
                flowFocusField.choices = choices;
                var focused = FrameAnimationFlowFocusPolicy.FindFocusedFlow(graph, focusedFlowId);
                flowFocusField.SetValueWithoutNotify(focused != null ? FlowChoiceLabel(focused) : "All Flows");
            }
            RefreshFlowFocusUi();
        }

        private void EnterFlowFocus(string flowId)
        {
            var flow = FrameAnimationFlowFocusPolicy.FindFocusedFlow(graph, flowId);
            if (flow == null)
            {
                ExitFlowFocus(false);
                return;
            }
            focusedFlowId = flow.Id;
            RefreshFlowChoices();
            graphView?.SetFocusedFlow(focusedFlowId);
        }

        private void ExitFlowFocus(bool frameAll)
        {
            focusedFlowId = string.Empty;
            RefreshFlowChoices();
            graphView?.SetFocusedFlow(string.Empty);
            if (frameAll)
            {
                graphView?.FrameAll();
            }
        }

        private void RevalidateFlowFocus()
        {
            if (string.IsNullOrEmpty(focusedFlowId))
            {
                RefreshFlowFocusUi();
                return;
            }
            var flow = FrameAnimationFlowFocusPolicy.FindFocusedFlow(graph, focusedFlowId);
            if (flow == null)
            {
                if (selection.Kind == FrameAnimationEditorSelectionKind.Flow &&
                    selection.Value is AnimationFlow selectedFlow && graph?.Flows.Contains(selectedFlow) == true)
                {
                    EnterFlowFocus(selectedFlow.Id);
                }
                else
                {
                    ExitFlowFocus(false);
                }
                return;
            }
            if (selection.Kind == FrameAnimationEditorSelectionKind.Flow &&
                selection.Value is AnimationFlow activeSelection &&
                graph.Flows.Contains(activeSelection) && activeSelection != flow)
            {
                EnterFlowFocus(activeSelection.Id);
                return;
            }
            var selectedElementWasRemoved = selection.Value switch
            {
                AnimationNode node => !graph.Nodes.Contains(node),
                AnimationEdge edge => !graph.Edges.Contains(edge),
                _ => false
            };
            if (selectedElementWasRemoved)
            {
                selection = new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Flow, flow);
                lastSelectedNode = null;
                RefreshInspector();
                SaveWorkspaceState();
            }
            if (FrameAnimationFlowFocusPolicy.ShouldExitForSelection(graph, focusedFlowId, selection))
            {
                ExitFlowFocus(false);
                return;
            }
            RefreshFlowChoices();
            graphView?.SetFocusedFlow(focusedFlowId);
        }

        private void RefreshFlowFocusUi()
        {
            var flow = FrameAnimationFlowFocusPolicy.FindFocusedFlow(graph, focusedFlowId);
            if (flowFocusField != null)
            {
                flowFocusField.tooltip = flow != null
                    ? $"Focused Flow: {flow.DisplayName} ({flow.Id})"
                    : "Show every Flow without assigning shared paths to one color";
                if (flow != null)
                {
                    var palette = FrameAnimationFlowColorUtility.CreatePalette(
                        FrameAnimationFlowColorUtility.ResolveRaw(graph, flow));
                    flowFocusField.style.borderLeftWidth = 3f;
                    flowFocusField.style.borderLeftColor = palette.Stroke;
                }
                else
                {
                    flowFocusField.style.borderLeftWidth = 0f;
                    flowFocusField.style.borderLeftColor = StyleKeyword.Null;
                }
            }
        }

        private void OnCanvasSelectionSetChanged(IReadOnlyList<FrameAnimationEditorSelection> selections)
        {
            if (FrameAnimationFlowFocusPolicy.ShouldExitForSelectionSet(graph, focusedFlowId, selections))
            {
                ExitFlowFocus(false);
            }
        }

        private void ShowAllNodes()
        {
            ExitFlowFocus(true);
        }

        private void CreateFlowFromCanvasSelection()
        {
            var nodes = graphView?.SelectedNodes ?? Array.Empty<AnimationNode>();
            if (nodes.Count != 1)
            {
                ShowNotification(new GUIContent("创建 Flow 必须且只能选中一个节点。"));
                return;
            }
            ShowCreateFlow(nodes[0]);
        }

        private void ShowCreateFlow(AnimationNode entry)
        {
            if (graph == null || entry == null || !graph.Nodes.Contains(entry))
            {
                ShowNotification(new GUIContent("Flow 入口节点已失效。"));
                return;
            }
            FrameAnimationFlowWindow.Show(graph, entry, flow =>
            {
                SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Flow, flow), false);
                OnCanvasGraphChanged();
            });
        }

        private void AutoLayoutCanvas()
        {
            if (graph == null)
            {
                return;
            }
            IReadOnlyList<AnimationNode> scope;
            var selected = graphView?.SelectedNodes ?? Array.Empty<AnimationNode>();
            if (selected.Count >= 2)
            {
                scope = selected;
            }
            else if (!string.IsNullOrEmpty(focusedFlowId))
            {
                var flow = graph.Flows.FirstOrDefault(item => item != null && item.Id == focusedFlowId);
                scope = flow != null
                    ? new FrameAnimationGraphTopology(graph).GetReachable(flow.EntryNodeId).Nodes
                    : Array.Empty<AnimationNode>();
            }
            else
            {
                scope = graph.Nodes.Where(node => node != null).ToArray();
            }
            var positions = FrameAnimationGraphLayoutService.Calculate(graph, scope);
            FrameAnimationGraphMutationService.SetNodePositions(graph, positions, "Auto Layout Frame Animation Graph");
            graphView?.ApplyCalculatedPositions(positions);
            ScheduleLightValidation();
        }

        private FrameAnimationBrowserIssueState GetIssueState(FrameAnimationEditorSelectionKind kind, object value)
        {
            var matching = validationIssues.Where(issue =>
                issue.Selection.Kind == kind && ReferenceEquals(issue.Selection.Value, value)).ToArray();
            if (matching.Any(issue => issue.Severity == FrameAnimationValidationSeverity.Error))
            {
                return FrameAnimationBrowserIssueState.Error;
            }
            return matching.Length > 0 ? FrameAnimationBrowserIssueState.Warning : FrameAnimationBrowserIssueState.None;
        }

        private void RefreshCanvasSummary()
        {
            RefreshGraphNavigation();
            if (canvasLabel == null)
            {
                return;
            }
            if (graph == null)
            {
                canvasLabel.text = "选择或创建 FrameAnimationGraph";
                canvasLabel.style.display = DisplayStyle.Flex;
                return;
            }
            canvasLabel.style.display = graph.Nodes.Count == 0 ? DisplayStyle.Flex : DisplayStyle.None;
            var located = selection.Kind == FrameAnimationEditorSelectionKind.None
                ? "Graph"
                : selection.Kind + ": " + SelectionName(selection);
            canvasLabel.text =
                $"右键或从 Clips 拖入以创建节点\n\n{graph.DisplayName} ({graph.Id})\n" +
                $"Clips {graph.Clips.Count}  Nodes {graph.Nodes.Count}  Edges {graph.Edges.Count}  Flows {graph.Flows.Count}\n\n" +
                $"当前定位：{located}";
        }

        private void RefreshGraphNavigation()
        {
            var hasGraph = graph != null;
            graphPropertiesButton?.SetEnabled(hasGraph);
            graphBreadcrumbButton?.SetEnabled(hasGraph);
            if (graphBreadcrumbButton == null)
            {
                return;
            }

            var graphName = !hasGraph
                ? "Graph"
                : string.IsNullOrWhiteSpace(graph.DisplayName) ? graph.Id : graph.DisplayName;
            graphBreadcrumbButton.text = $"Graph: {graphName}";
            graphBreadcrumbButton.tooltip = hasGraph
                ? $"查看和编辑 {graphName} 的 Graph 参数"
                : "未选择 Graph";
        }

        private static string SelectionName(FrameAnimationEditorSelection selected)
        {
            return selected.Value switch
            {
                FrameClip clip => clip.Id,
                AnimationFlow flow => flow.Id,
                FrameAnimationImportSource source => source.DisplayName,
                AnimationNode node => node.InternalId,
                AnimationEdge edge => edge.InternalId,
                FrameAnimationGraph selectedGraph => selectedGraph.Id,
                _ => string.Empty
            };
        }

        private void RefreshInspector()
        {
            if (propertyContainer == null) return;
            propertyContainer.Clear();
            if (graph == null)
            {
                propertyContainer.Add(CreateCallout("请选择 FrameAnimationGraph。"));
                return;
            }
            if (multiSelectedNodes.Count > 1)
            {
                AddInspectorTitle("Multiple Nodes", $"{multiSelectedNodes.Count} selected");
                var section = CreateInspectorSection("Selection", out var body);
                body.Add(CreateCallout("可对当前选中的节点执行自动布局或安全删除。"));
                body.Add(new Button(() =>
                {
                    var positions = FrameAnimationGraphLayoutService.Calculate(graph, multiSelectedNodes);
                    FrameAnimationGraphMutationService.SetNodePositions(
                        graph, positions, "Auto Layout Selected Frame Animation Nodes");
                    graphView?.ApplyCalculatedPositions(positions);
                }) { text = "Auto Layout Selected Nodes" });
                var delete = new Button(() => graphView?.RequestDeleteNodes(multiSelectedNodes))
                    { text = "Delete Selected Nodes" };
                delete.AddToClassList("fa-button--danger");
                body.Add(delete);
                propertyContainer.Add(section);
                return;
            }

            switch (selection.Kind)
            {
                case FrameAnimationEditorSelectionKind.Clip:
                    BuildClipInspector(selection.Value as FrameClip);
                    break;
                case FrameAnimationEditorSelectionKind.Flow:
                    BuildFlowInspector(selection.Value as AnimationFlow);
                    break;
                case FrameAnimationEditorSelectionKind.Source:
                    BuildSourceInspector(selection.Value as FrameAnimationImportSource);
                    break;
                case FrameAnimationEditorSelectionKind.Node:
                    BuildNodeInspector(selection.Value as AnimationNode);
                    break;
                case FrameAnimationEditorSelectionKind.Edge:
                    BuildEdgeInspector(selection.Value as AnimationEdge);
                    break;
                default:
                    BuildGraphInspector();
                    break;
            }
        }

        private void AddInspectorTitle(string name, string id)
        {
            var title = new VisualElement();
            title.AddToClassList("fa-inspector-title");
            var nameLabel = new Label(name);
            nameLabel.AddToClassList("fa-inspector-title__name");
            var idLabel = new Label(id ?? string.Empty);
            idLabel.AddToClassList("fa-inspector-title__id");
            title.Add(nameLabel);
            title.Add(idLabel);
            propertyContainer.Add(title);
        }

        private static VisualElement CreateInspectorSection(string title, out VisualElement body)
        {
            var section = new VisualElement();
            section.AddToClassList("fa-section");
            var titleLabel = new Label(title);
            titleLabel.AddToClassList("fa-section__title");
            body = new VisualElement();
            body.AddToClassList("fa-section__body");
            section.Add(titleLabel);
            section.Add(body);
            return section;
        }

        private static Label CreateCallout(string text, string modifier = null)
        {
            var label = new Label(text);
            label.AddToClassList("fa-callout");
            if (!string.IsNullOrEmpty(modifier)) label.AddToClassList(modifier);
            return label;
        }

        private static void AddReadOnly(VisualElement body, string label, object value)
        {
            var row = new VisualElement();
            row.AddToClassList("fa-readonly-row");
            var name = new Label(label);
            name.AddToClassList("fa-readonly-row__label");
            var content = new Label(value?.ToString() ?? string.Empty);
            content.AddToClassList("fa-readonly-row__value");
            row.Add(name);
            row.Add(content);
            body.Add(row);
        }

        private static PropertyField AddBoundProperty(
            VisualElement body,
            SerializedObject serialized,
            SerializedProperty property,
            string label = null,
            bool enabled = true)
        {
            var field = new PropertyField(property, label ?? property.displayName);
            field.SetEnabled(enabled);
            body.Add(field);
            field.Bind(serialized);
            return field;
        }

        private void TrackInspectorEdits(VisualElement element, UnityEngine.Object target)
        {
            element.RegisterCallback<FocusOutEvent>(_ =>
            {
                if (target != null) EditorUtility.SetDirty(target);
                previewCoordinator.RefreshTarget(false);
                ScheduleLightValidation();
                RefreshBrowser();
                RefreshGraphView();
                RefreshCanvasSummary();
            });
        }

        private void BuildGraphInspector()
        {
            AddInspectorTitle(graph.DisplayName, graph.Id);
            var section = CreateInspectorSection("Graph", out var body);
            var serialized = new SerializedObject(graph);
            serialized.Update();
            AddBoundProperty(body, serialized, serialized.FindProperty("displayName"), "Display Name");
            AddReadOnly(body, "ID", graph.Id);
            AddReadOnly(body, "Clips", graph.Clips.Count);
            AddReadOnly(body, "Flows", graph.Flows.Count);
            AddReadOnly(body, "Sources", graph.ImportSources.Count);

            var playableIds = new List<string> { string.Empty };
            playableIds.AddRange(graph.Clips.Where(clip => clip != null).Select(clip => clip.Id));
            playableIds.AddRange(graph.Flows.Where(flow => flow != null).Select(flow => flow.Id));
            var labels = playableIds.Select(id => string.IsNullOrEmpty(id) ? "<None>" : id).ToList();
            var selectedIndex = Mathf.Max(0, playableIds.IndexOf(graph.Settings.DefaultPlayableId));
            var defaultPlayable = new PopupField<string>("Default Playable", labels, selectedIndex);
            defaultPlayable.RegisterValueChangedCallback(evt =>
            {
                var index = labels.IndexOf(evt.newValue);
                if (index < 0) return;
                Undo.RecordObject(graph, "Set Default Frame Animation Playable");
                graph.Settings.SetDefaultPlayableId(playableIds[index]);
                EditorUtility.SetDirty(graph);
            });
            body.Add(defaultPlayable);
            var endBehavior = new EnumField("New Manual End Behavior", graph.Settings.NewManualClipDefaultEndBehavior);
            endBehavior.RegisterValueChangedCallback(evt =>
            {
                Undo.RecordObject(graph, "Set New Manual Clip End Behavior");
                graph.Settings.SetNewManualClipDefaultEndBehavior((FrameClipEndBehavior)evt.newValue);
                EditorUtility.SetDirty(graph);
            });
            body.Add(endBehavior);
            body.Add(new Button(ShowRenameGraph) { text = "Rename Graph ID" });
            TrackInspectorEdits(section, graph);
            propertyContainer.Add(section);
        }

        private void BuildClipInspector(FrameClip clip)
        {
            if (clip == null)
            {
                propertyContainer.Add(CreateCallout("Clip 已失效。", "fa-callout--warning"));
                return;
            }
            AddInspectorTitle(clip.DisplayName, clip.Id);
            var details = CreateInspectorSection(clip.IsImported ? "Imported Clip" : "Manual Clip", out var body);
            var serialized = new SerializedObject(clip);
            serialized.Update();
            AddReadOnly(body, "ID", clip.Id);
            AddBoundProperty(body, serialized, serialized.FindProperty("displayName"), "Display Name");
            AddBoundProperty(body, serialized, serialized.FindProperty("speed"), "Speed");
            AddBoundProperty(body, serialized, serialized.FindProperty("defaultEndBehavior"), "Default End Behavior");
            AddReadOnly(body, "Frame Count", clip.FrameCount);
            AddReadOnly(body, "Total Duration", clip.TotalDurationMs + " ms");
            AddReadOnly(body, "Storage", AssetDatabase.IsSubAsset(clip) ? "Graph sub-asset" : "External .asset");
            if (clip.IsImported)
            {
                AddReadOnly(body, "Source Tag", clip.ImportInfo.SourceTagName);
                AddReadOnly(body, "Missing", clip.ImportInfo.IsMissingFromSource ? "Yes" : "No");
            }
            var owners = FrameAnimationAssetReferenceIndex.FindGraphsReferencing(clip);
            if (!AssetDatabase.IsSubAsset(clip) && owners.Count > 1)
            {
                body.Add(CreateCallout("共享外部 Manual Clip：" + string.Join(", ", owners.Select(owner => owner.name)),
                    "fa-callout--warning"));
            }
            TrackInspectorEdits(details, clip);
            propertyContainer.Add(details);

            var frames = CreateInspectorSection("Frames", out var frameBody);
            BuildFrameList(frameBody, clip);
            propertyContainer.Add(frames);

            var actions = CreateInspectorSection("Actions", out var actionBody);
            if (clip.IsImported)
            {
                actionBody.Add(new Button(() =>
                {
                    var source = graph.ImportSources.FirstOrDefault(item => item != null &&
                        item.InternalId == clip.ImportInfo.ImportSourceId);
                    SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Source, source));
                    SetResourceTab(ResourceTab.Sources);
                }) { text = "Locate ImportSource" });
                actionBody.Add(new Button(() => FrameAnimationManualClipWindow.Show(graph, clip, copied =>
                {
                    RefreshBrowser();
                    SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Clip, copied));
                })) { text = "Copy As Manual Clip" });
            }
            actionBody.Add(new Button(() => ShowRenameClip(clip)) { text = "Rename Clip ID" });
            actionBody.Add(new Button(() => LocateClipReferences(clip)) { text = "Locate Node References" });
            var remove = new Button(() => ConfirmRemoveClip(clip))
            {
                text = AssetDatabase.IsSubAsset(clip) ? "Delete Clip Sub-Asset" : "Remove Clip Reference"
            };
            remove.AddToClassList("fa-button--danger");
            actionBody.Add(remove);
            propertyContainer.Add(actions);
        }

        private void BuildFrameList(VisualElement body, FrameClip clip)
        {
            var indices = Enumerable.Range(0, clip.FrameCount).ToList();
            var list = new ListView(indices, 72f,
                () => new FrameAnimationFrameRowElement(),
                (element, index) => ((FrameAnimationFrameRowElement)element).Bind(
                    clip, index, clip.IsImported, OnFrameInspectorChanged))
            {
                selectionType = SelectionType.Single,
                style = { height = Mathf.Clamp(clip.FrameCount * 72f + 2f, 74f, 360f) }
            };
            body.Add(list);
            if (clip.IsImported) return;
            var controls = new VisualElement { style = { flexDirection = FlexDirection.Row } };
            controls.Add(new Button(() => MutateFrames(clip, list.selectedIndex, FrameMutation.Add)) { text = "+" });
            controls.Add(new Button(() => MutateFrames(clip, list.selectedIndex, FrameMutation.Duplicate)) { text = "Duplicate" });
            controls.Add(new Button(() => MutateFrames(clip, list.selectedIndex, FrameMutation.MoveUp)) { text = "↑" });
            controls.Add(new Button(() => MutateFrames(clip, list.selectedIndex, FrameMutation.MoveDown)) { text = "↓" });
            var remove = new Button(() => MutateFrames(clip, list.selectedIndex, FrameMutation.Remove)) { text = "−" };
            remove.AddToClassList("fa-button--danger");
            controls.Add(remove);
            body.Add(controls);
        }

        private enum FrameMutation { Add, Duplicate, Remove, MoveUp, MoveDown }

        private void MutateFrames(FrameClip clip, int selectedIndex, FrameMutation mutation)
        {
            if (clip == null || clip.IsImported) return;
            var serialized = new SerializedObject(clip);
            serialized.Update();
            var frames = serialized.FindProperty("frames");
            Undo.RecordObject(clip, "Edit Frame Animation Frames");
            if (mutation == FrameMutation.Add)
            {
                var index = frames.arraySize;
                frames.InsertArrayElementAtIndex(index);
                var frame = frames.GetArrayElementAtIndex(index);
                frame.FindPropertyRelative("sprite").objectReferenceValue = null;
                frame.FindPropertyRelative("durationMs").intValue = 100;
                frame.FindPropertyRelative("frameName").stringValue = string.Empty;
                frame.FindPropertyRelative("sourceIndex").intValue = -1;
            }
            else if (selectedIndex >= 0 && selectedIndex < frames.arraySize)
            {
                if (mutation == FrameMutation.Duplicate) frames.InsertArrayElementAtIndex(selectedIndex);
                else if (mutation == FrameMutation.Remove) frames.DeleteArrayElementAtIndex(selectedIndex);
                else if (mutation == FrameMutation.MoveUp && selectedIndex > 0)
                    frames.MoveArrayElement(selectedIndex, selectedIndex - 1);
                else if (mutation == FrameMutation.MoveDown && selectedIndex < frames.arraySize - 1)
                    frames.MoveArrayElement(selectedIndex, selectedIndex + 1);
            }
            serialized.ApplyModifiedProperties();
            EditorUtility.SetDirty(clip);
            OnFrameInspectorChanged();
            RefreshInspector();
        }

        private void OnFrameInspectorChanged()
        {
            previewCoordinator.RefreshTarget(false);
            ScheduleLightValidation();
            RefreshBrowser();
            RefreshGraphView();
        }

        private void BuildFlowInspector(AnimationFlow flow)
        {
            var index = graph.Flows.ToList().IndexOf(flow);
            if (flow == null || index < 0)
            {
                propertyContainer.Add(CreateCallout("Flow 已失效。", "fa-callout--warning"));
                return;
            }
            AddInspectorTitle(flow.DisplayName, flow.Id);
            var section = CreateInspectorSection("Animation Flow", out var body);
            var serialized = new SerializedObject(graph);
            serialized.Update();
            var property = serialized.FindProperty("flows").GetArrayElementAtIndex(index);
            AddReadOnly(body, "ID", flow.Id);
            AddReadOnly(body, "Entry Node", flow.EntryNodeId);
            AddBoundProperty(body, serialized, property.FindPropertyRelative("displayName"), "Display Name");
            AddBoundProperty(body, serialized, property.FindPropertyRelative("hasEndBehaviorOverride"), "Override End Behavior");
            AddBoundProperty(body, serialized, property.FindPropertyRelative("endBehaviorOverride"), "End Behavior");

            var color = FrameAnimationFlowColorUtility.ResolveStored(graph, flow);
            var colorField = new ColorField("Canvas Color") { value = color, showAlpha = true };
            colorField.RegisterValueChangedCallback(evt =>
            {
                FrameAnimationGraphMutationService.SetFlowColor(graph, flow, evt.newValue);
                RefreshBrowser();
                RefreshFlowFocusUi();
                RefreshGraphView();
            });
            body.Add(colorField);
            AddReadOnly(body, "Entry Candidate", lastSelectedNode != null && graph.Nodes.Contains(lastSelectedNode)
                ? $"{lastSelectedNode.DisplayName} ({lastSelectedNode.InternalId})"
                : "<Select a Node on canvas>");
            var setEntry = new Button(() =>
            {
                if (!FrameAnimationGraphMutationService.SetFlowEntry(graph, flow, lastSelectedNode, out var error))
                {
                    EditorUtility.DisplayDialog("无法修改 Flow 入口", error, "确定");
                    return;
                }
                EnterFlowFocus(flow.Id);
                OnCanvasGraphChanged();
            }) { text = "Set Selected Node As Entry" };
            setEntry.SetEnabled(lastSelectedNode != null && graph.Nodes.Contains(lastSelectedNode));
            body.Add(setEntry);
            TrackInspectorEdits(section, graph);
            propertyContainer.Add(section);

            var actions = CreateInspectorSection("Actions", out var actionBody);
            actionBody.Add(new Button(() =>
            {
                EnterFlowFocus(flow.Id);
                graphView?.FrameCurrentFlow(flow.Id);
            }) { text = "Focus Flow On Canvas" });
            actionBody.Add(new Button(() => ShowRenameFlow(flow)) { text = "Rename Flow ID" });
            var delete = new Button(() => DeleteFlowFromInspector(flow)) { text = "Delete Flow" };
            delete.AddToClassList("fa-button--danger");
            actionBody.Add(delete);
            propertyContainer.Add(actions);
        }

        private void DeleteFlowFromInspector(AnimationFlow flow)
        {
            if (!FrameAnimationAssetOperations.CanRemoveFlow(graph, flow, out var blocker))
            {
                EditorUtility.DisplayDialog("无法删除 Flow", blocker, "确定");
                return;
            }
            if (!EditorUtility.DisplayDialog("确认删除 Flow", "只删除 Flow 定义，不会删除其 Node 或 Edge。是否继续？",
                    "删除", "取消")) return;
            if (!FrameAnimationAssetOperations.RemoveFlow(graph, flow, out var error))
            {
                EditorUtility.DisplayDialog("无法删除 Flow", error, "确定");
                return;
            }
            ExitFlowFocus(false);
            SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Graph, graph));
            OnCanvasGraphChanged();
        }

        private void BuildSourceInspector(FrameAnimationImportSource source)
        {
            var index = graph.ImportSources.ToList().IndexOf(source);
            if (source == null || index < 0)
            {
                propertyContainer.Add(CreateCallout("ImportSource 已失效。", "fa-callout--warning"));
                return;
            }
            AddInspectorTitle(source.DisplayName, source.InternalId);
            var section = CreateInspectorSection("Import Source", out var body);
            var serialized = new SerializedObject(graph);
            serialized.Update();
            var property = serialized.FindProperty("importSources").GetArrayElementAtIndex(index);
            AddReadOnly(body, "Internal ID", source.InternalId);
            AddBoundProperty(body, serialized, property.FindPropertyRelative("displayName"), "Display Name");
            AddBoundProperty(body, serialized, property.FindPropertyRelative("isEnabled"), "Enabled");
            AddBoundProperty(body, serialized, property.FindPropertyRelative("texture"), "Texture");
            AddBoundProperty(body, serialized, property.FindPropertyRelative("asepriteJson"), "Aseprite JSON");
            AddBoundProperty(body, serialized, property.FindPropertyRelative("pivot"), "Pivot");
            AddBoundProperty(body, serialized, property.FindPropertyRelative("manageSpriteSlicing"), "Manage Sprite Slicing");
            AddBoundProperty(body, serialized, property.FindPropertyRelative("defaultNewClipEndBehavior"), "Default Clip End");
            AddReadOnly(body, "Last Source Hash", source.LastSourceHash);
            AddReadOnly(body, "Associated Clips", graph.Clips.Count(clip => clip != null &&
                clip.ImportInfo?.ImportSourceId == source.InternalId));
            body.Add(new Button(() => GUIUtility.systemCopyBuffer = source.InternalId) { text = "Copy Internal ID" });
            TrackInspectorEdits(section, graph);
            propertyContainer.Add(section);

            var actions = CreateInspectorSection("Import", out var actionBody);
            actionBody.Add(new Button(() =>
            {
                importPreview = FrameAnimationImportService.PreviewSource(graph, source.InternalId);
                SetBottomTab(BottomTab.ImportDiff);
            }) { text = "Preview Source" });
            actionBody.Add(new Button(() =>
            {
                importPreview = FrameAnimationImportService.PreviewSource(graph, source.InternalId);
                ApplyImportPreview();
            }) { text = "Refresh Source" });
            var remove = new Button(() => RemoveSourceFromInspector(source)) { text = "Remove ImportSource" };
            remove.AddToClassList("fa-button--danger");
            actionBody.Add(remove);
            propertyContainer.Add(actions);
        }

        private void RemoveSourceFromInspector(FrameAnimationImportSource source)
        {
            var associated = graph.Clips.Where(clip => clip != null &&
                clip.ImportInfo?.ImportSourceId == source.InternalId).ToArray();
            if (associated.Length > 0)
            {
                EditorUtility.DisplayDialog("无法删除 ImportSource",
                    "仍关联 Imported Clip：" + string.Join(", ", associated.Select(clip => clip.Id)), "确定");
                return;
            }
            if (!EditorUtility.DisplayDialog("删除 ImportSource",
                    "该操作不会删除 Texture、JSON、Sprite 或 SpriteRect。确认删除来源？", "删除", "取消")) return;
            if (!FrameAnimationAssetOperations.RemoveSource(graph, source, out var error))
            {
                EditorUtility.DisplayDialog("无法删除 ImportSource", error, "确定");
                return;
            }
            SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Graph, graph));
            RefreshBrowser();
        }

        private void BuildNodeInspector(AnimationNode node)
        {
            if (node == null || !graph.Nodes.Contains(node))
            {
                propertyContainer.Add(CreateCallout("Node 已失效。", "fa-callout--warning"));
                return;
            }
            AddInspectorTitle(string.IsNullOrEmpty(node.DisplayName) ? node.ClipId : node.DisplayName, node.InternalId);
            var section = CreateInspectorSection("Animation Node", out var body);
            AddReadOnly(body, "Internal ID", node.InternalId);
            var name = new TextField("Display Name") { value = node.DisplayName, isDelayed = true };
            name.RegisterValueChangedCallback(evt =>
            {
                FrameAnimationGraphMutationService.SetNodeDisplayName(graph, node, evt.newValue);
                OnCanvasGraphChanged();
            });
            body.Add(name);

            var clips = graph.Clips.Where(clip => clip != null).ToList();
            var clipLabels = clips.Select(clip => $"{clip.DisplayName} ({clip.Id})").ToList();
            var current = clips.FindIndex(clip => clip.Id == node.ClipId);
            if (current < 0) clipLabels.Insert(0, $"<Missing: {node.ClipId}>");
            var clipField = new PopupField<string>("Clip", clipLabels, Mathf.Max(0, current));
            clipField.RegisterValueChangedCallback(evt =>
            {
                var selectedIndex = clipLabels.IndexOf(evt.newValue);
                if (current < 0) selectedIndex--;
                if (selectedIndex < 0 || selectedIndex >= clips.Count) return;
                FrameAnimationGraphMutationService.SetNodeClip(graph, node, clips[selectedIndex]);
                OnCanvasGraphChanged();
            });
            body.Add(clipField);

            var speedToggle = new Toggle("Override Speed") { value = node.SpeedOverride.HasValue };
            var speed = new FloatField("Speed") { value = node.SpeedOverride ?? 1f };
            speed.SetEnabled(speedToggle.value);
            speedToggle.RegisterValueChangedCallback(evt =>
            {
                speed.SetEnabled(evt.newValue);
                FrameAnimationGraphMutationService.SetNodeSpeed(graph, node, evt.newValue ? speed.value : (float?)null);
                OnCanvasGraphChanged();
            });
            speed.RegisterValueChangedCallback(evt =>
            {
                if (!speedToggle.value) return;
                FrameAnimationGraphMutationService.SetNodeSpeed(graph, node, evt.newValue);
                OnCanvasGraphChanged();
            });
            body.Add(speedToggle);
            body.Add(speed);

            var endToggle = new Toggle("Override End Behavior") { value = node.EndBehaviorOverride.HasValue };
            var end = new EnumField("End Behavior", node.EndBehaviorOverride ?? FrameClipEndBehavior.HoldLastFrame);
            end.SetEnabled(endToggle.value);
            endToggle.RegisterValueChangedCallback(evt => ApplyNodeEndBehavior(node, evt.newValue,
                (FrameClipEndBehavior)end.value, end));
            end.RegisterValueChangedCallback(evt =>
            {
                if (endToggle.value) ApplyNodeEndBehavior(node, true, (FrameClipEndBehavior)evt.newValue, end);
            });
            body.Add(endToggle);
            body.Add(end);
            var flows = new FrameAnimationGraphTopology(graph).FindFlowsUsingNode(node.InternalId);
            AddReadOnly(body, "Used By Flows", flows.Count == 0 ? "None" : string.Join(", ", flows.Select(flow => flow.Id)));
            body.Add(new Button(() => GUIUtility.systemCopyBuffer = node.InternalId) { text = "Copy Internal ID" });
            propertyContainer.Add(section);

            var actions = CreateInspectorSection("Actions", out var actionBody);
            actionBody.Add(new Button(() => ShowCreateFlow(node)) { text = "Create Flow From Node" });
            var delete = new Button(() => graphView?.RequestDeleteNodes(new[] { node })) { text = "Delete Node" };
            delete.AddToClassList("fa-button--danger");
            actionBody.Add(delete);
            propertyContainer.Add(actions);
        }

        private void ApplyNodeEndBehavior(AnimationNode node, bool enabled, FrameClipEndBehavior behavior, VisualElement field)
        {
            field.SetEnabled(enabled);
            var outgoing = graph.Edges.Where(edge => edge != null && edge.FromNodeId == node.InternalId).ToArray();
            var removeOutgoing = outgoing.Length == 0 || !enabled || EditorUtility.DisplayDialog(
                "终点行为与后继冲突", "该节点已有后继 Edge。设置结束行为会删除该 Edge，是否继续？",
                "删除 Edge 并应用", "取消");
            if (!removeOutgoing) return;
            if (FrameAnimationGraphMutationService.SetNodeEndBehavior(graph, node,
                    enabled ? behavior : (FrameClipEndBehavior?)null, outgoing.Length > 0, out var error))
            {
                OnCanvasGraphChanged();
            }
            else if (!string.IsNullOrEmpty(error))
            {
                EditorUtility.DisplayDialog("无法修改结束行为", error, "确定");
            }
        }

        private void BuildEdgeInspector(AnimationEdge edge)
        {
            if (edge == null || !graph.Edges.Contains(edge))
            {
                propertyContainer.Add(CreateCallout("Edge 已失效。", "fa-callout--warning"));
                return;
            }
            AddInspectorTitle("Animation Edge", edge.InternalId);
            var section = CreateInspectorSection("Connection", out var body);
            AddReadOnly(body, "From", edge.FromNodeId);
            AddReadOnly(body, "To", edge.ToNodeId);
            AddReadOnly(body, "Exit", edge.ExitName);
            AddReadOnly(body, "Condition", edge.Condition);
            propertyContainer.Add(section);
            var actions = CreateInspectorSection("Actions", out var actionBody);
            var disconnect = new Button(() => graphView?.RequestDeleteEdges(new[] { edge })) { text = "Disconnect Edge" };
            disconnect.AddToClassList("fa-button--danger");
            actionBody.Add(disconnect);
            propertyContainer.Add(actions);
        }

        private void RefreshBottomPanel()
        {
            if (bottomContainer == null) return;
            bottomContainer.Clear();
            if (bottomCollapsed) return;
            RefreshTabStyles();
            if (bottomTab == BottomTab.ImportDiff) BuildImportDiffPanel();
            else BuildValidationPanel();
        }

        private void BuildValidationPanel()
        {
            var controls = new VisualElement();
            controls.AddToClassList("fa-result-controls");
            controls.Add(CreateSeverityToggle("Errors", showErrors, value => showErrors = value));
            controls.Add(CreateSeverityToggle("Warnings", showWarnings, value => showWarnings = value));
            controls.Add(CreateSeverityToggle("Info", showInfo, value => showInfo = value));
            var filter = new EnumField(validationKindFilter) { style = { width = 130f } };
            filter.RegisterValueChangedCallback(evt =>
            {
                validationKindFilter = (ValidationKindFilter)evt.newValue;
                SaveWorkspaceState();
                RefreshBottomPanel();
            });
            controls.Add(filter);
            var rerun = new Button(ValidateFull) { text = "Run Validation" };
            rerun.AddToClassList("fa-button--primary");
            controls.Add(rerun);
            bottomContainer.Add(controls);
            bottomContainer.Add(CreateResultHeader("Severity", "Kind", "Object", "Message / Suggestion"));
            foreach (var issue in validationIssues.Where(ShowIssue))
            {
                var message = string.IsNullOrEmpty(issue.Suggestion)
                    ? issue.Message : issue.Message + "  ·  建议：" + issue.Suggestion;
                var row = CreateResultRow(issue.Severity.ToString(), issue.Selection.Kind.ToString(),
                    SelectionName(issue.Selection), $"[{issue.Code}] {message}", issue.Severity);
                if (issue.Selection.Value != null)
                {
                    row.RegisterCallback<PointerDownEvent>(evt =>
                    {
                        if (evt.button != 0) return;
                        SetSelection(issue.Selection);
                        SetResourceTab(issue.Selection.Kind switch
                        {
                            FrameAnimationEditorSelectionKind.Clip => ResourceTab.Clips,
                            FrameAnimationEditorSelectionKind.Flow => ResourceTab.Flows,
                            FrameAnimationEditorSelectionKind.Source => ResourceTab.Sources,
                            _ => resourceTab
                        });
                    });
                }
                bottomContainer.Add(row);
            }
        }

        private Toggle CreateSeverityToggle(string text, bool value, Action<bool> setter)
        {
            var toggle = new Toggle(text) { value = value };
            toggle.RegisterValueChangedCallback(evt =>
            {
                setter(evt.newValue);
                RefreshBottomPanel();
            });
            return toggle;
        }

        private void BuildImportDiffPanel()
        {
            if (importPreview == null)
            {
                bottomContainer.Add(CreateCallout("点击 Preview Imports 或来源 Preview 计算导入差异。"));
                return;
            }
            bottomContainer.Add(CreateResultHeader("Status", "Type", "Object", "Summary"));
            foreach (var source in importPreview.Sources)
            {
                var sourceRow = CreateResultRow("SOURCE", "ImportSource", source.Source.DisplayName,
                    source.Document == null ? "无法读取来源文档" :
                    $"{source.Document.Frames.Count} logical frames · {source.Document.SpriteSlots.Count} sprite slots",
                    null);
                sourceRow.RegisterCallback<PointerDownEvent>(evt =>
                {
                    if (evt.button != 0) return;
                    SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Source, source.Source));
                    SetResourceTab(ResourceTab.Sources);
                });
                bottomContainer.Add(sourceRow);
                foreach (var issue in source.Issues)
                {
                    bottomContainer.Add(CreateResultRow(issue.Severity.ToString(), "Import Issue",
                        issue.TargetId, $"[{issue.Code}] {issue.Message}", issue.Severity));
                }
                foreach (var diff in source.ClipDiffs)
                {
                    var severity = diff.Kind == FrameAnimationImportChangeKind.Error
                        ? FrameAnimationValidationSeverity.Error
                        : diff.Kind == FrameAnimationImportChangeKind.Missing
                            ? FrameAnimationValidationSeverity.Warning : (FrameAnimationValidationSeverity?)null;
                    var row = CreateResultRow(diff.Kind.ToString(), "FrameClip", diff.SourceTagName,
                        diff.Summary, severity);
                    if (diff.Clip != null)
                    {
                        row.RegisterCallback<PointerDownEvent>(evt =>
                        {
                            if (evt.button != 0) return;
                            SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Clip, diff.Clip));
                            SetResourceTab(ResourceTab.Clips);
                        });
                    }
                    bottomContainer.Add(row);
                }
                foreach (var diff in source.SpriteDiffs)
                {
                    var severity = diff.Kind == FrameAnimationSpriteChangeKind.Error
                        ? FrameAnimationValidationSeverity.Error : (FrameAnimationValidationSeverity?)null;
                    bottomContainer.Add(CreateResultRow(diff.Kind.ToString(), "SpriteRect", diff.FrameName,
                        $"{diff.Summary}  {diff.Rect}", severity));
                }
            }
        }

        private static VisualElement CreateResultHeader(string first, string second, string third, string fourth)
        {
            var row = CreateResultCells(first, second, third, fourth);
            row.AddToClassList("fa-result-header");
            return row;
        }

        private static VisualElement CreateResultRow(
            string first,
            string second,
            string third,
            string fourth,
            FrameAnimationValidationSeverity? severity)
        {
            var row = CreateResultCells(first, second, third, fourth);
            row.AddToClassList("fa-result-row");
            var severityLabel = row.Q<Label>(className: "fa-result-severity");
            if (severity == FrameAnimationValidationSeverity.Error) severityLabel.AddToClassList("fa-severity--error");
            else if (severity == FrameAnimationValidationSeverity.Warning) severityLabel.AddToClassList("fa-severity--warning");
            else if (severity == FrameAnimationValidationSeverity.Info) severityLabel.AddToClassList("fa-severity--info");
            return row;
        }

        private static VisualElement CreateResultCells(string first, string second, string third, string fourth)
        {
            var row = new VisualElement();
            var firstLabel = new Label(first ?? string.Empty);
            firstLabel.AddToClassList("fa-result-severity");
            var secondLabel = new Label(second ?? string.Empty);
            secondLabel.AddToClassList("fa-result-kind");
            var thirdLabel = new Label(third ?? string.Empty);
            thirdLabel.AddToClassList("fa-result-object");
            var fourthLabel = new Label(fourth ?? string.Empty);
            fourthLabel.AddToClassList("fa-result-message");
            row.Add(firstLabel);
            row.Add(secondLabel);
            row.Add(thirdLabel);
            row.Add(fourthLabel);
            return row;
        }

        private void DrawSelectionProperties()
        {
            if (graph == null)
            {
                EditorGUILayout.HelpBox("请选择 FrameAnimationGraph。", MessageType.Info);
                return;
            }

            if (multiSelectedNodes.Count > 1)
            {
                EditorGUILayout.LabelField("Multiple Nodes", EditorStyles.boldLabel);
                EditorGUILayout.LabelField("Selected", multiSelectedNodes.Count.ToString());
                EditorGUILayout.HelpBox("第四阶段不提供批量属性编辑。可以对选中节点执行自动布局或安全删除。", MessageType.Info);
                if (GUILayout.Button("Auto Layout Selected Nodes"))
                {
                    var positions = FrameAnimationGraphLayoutService.Calculate(graph, multiSelectedNodes);
                    FrameAnimationGraphMutationService.SetNodePositions(
                        graph, positions, "Auto Layout Selected Frame Animation Nodes");
                    graphView?.ApplyCalculatedPositions(positions);
                }
                if (GUILayout.Button("Delete Selected Nodes"))
                {
                    graphView?.RequestDeleteNodes(multiSelectedNodes);
                }
                return;
            }

            EditorGUI.BeginChangeCheck();
            switch (selection.Kind)
            {
                case FrameAnimationEditorSelectionKind.Clip:
                    DrawClipProperties(selection.Value as FrameClip);
                    break;
                case FrameAnimationEditorSelectionKind.Flow:
                    DrawFlowProperties(selection.Value as AnimationFlow);
                    break;
                case FrameAnimationEditorSelectionKind.Source:
                    DrawSourceProperties(selection.Value as FrameAnimationImportSource);
                    break;
                case FrameAnimationEditorSelectionKind.Node:
                    DrawNodeProperties(selection.Value as AnimationNode);
                    break;
                case FrameAnimationEditorSelectionKind.Edge:
                    DrawEdgeProperties(selection.Value as AnimationEdge);
                    break;
                default:
                    DrawGraphProperties();
                    break;
            }
            if (EditorGUI.EndChangeCheck())
            {
                previewCoordinator.RefreshTarget(false);
                ScheduleLightValidation();
                RefreshBrowser();
                RefreshCanvasSummary();
            }
        }

        private void DrawGraphProperties()
        {
            var serialized = new SerializedObject(graph);
            serialized.Update();
            EditorGUILayout.LabelField("Graph", EditorStyles.boldLabel);
            using (new EditorGUI.DisabledScope(true))
            {
                EditorGUILayout.PropertyField(serialized.FindProperty("id"));
            }
            EditorGUILayout.PropertyField(serialized.FindProperty("displayName"));
            EditorGUILayout.LabelField("Clips", graph.Clips.Count.ToString());
            EditorGUILayout.LabelField("Flows", graph.Flows.Count.ToString());
            EditorGUILayout.LabelField("Sources", graph.ImportSources.Count.ToString());
            DrawDefaultPlayablePopup();
            var currentEndBehavior = graph.Settings.NewManualClipDefaultEndBehavior;
            var nextEndBehavior = (FrameClipEndBehavior)EditorGUILayout.EnumPopup(
                "New Manual End Behavior", currentEndBehavior);
            if (nextEndBehavior != currentEndBehavior)
            {
                Undo.RecordObject(graph, "Set New Manual Clip End Behavior");
                graph.Settings.SetNewManualClipDefaultEndBehavior(nextEndBehavior);
                EditorUtility.SetDirty(graph);
            }
            if (serialized.ApplyModifiedProperties())
            {
                EditorUtility.SetDirty(graph);
            }
            if (GUILayout.Button("Rename Graph ID"))
            {
                ShowRenameGraph();
            }
        }

        private void DrawDefaultPlayablePopup()
        {
            var ids = new List<string> { string.Empty };
            ids.AddRange(graph.Clips.Where(clip => clip != null).Select(clip => clip.Id));
            ids.AddRange(graph.Flows.Where(flow => flow != null).Select(flow => flow.Id));
            var labels = ids.Select(id => string.IsNullOrEmpty(id) ? "<None>" : id).ToArray();
            var current = Mathf.Max(0, ids.IndexOf(graph.Settings.DefaultPlayableId));
            var next = EditorGUILayout.Popup("Default Playable", current, labels);
            if (next != current)
            {
                Undo.RecordObject(graph, "Set Default Frame Animation Playable");
                graph.Settings.SetDefaultPlayableId(ids[next]);
                EditorUtility.SetDirty(graph);
            }
        }

        private void DrawClipProperties(FrameClip clip)
        {
            if (clip == null)
            {
                EditorGUILayout.HelpBox("Clip 已失效。", MessageType.Warning);
                return;
            }
            EnsureFrameList(clip);
            clipSerializedObject.Update();
            EditorGUILayout.LabelField(
                clip.IsImported ? "Graph Imported Clip" :
                clip.HasStandaloneImportSource ? "Source-linked External Clip" : "Manual Clip",
                EditorStyles.boldLabel);
            using (new EditorGUI.DisabledScope(true))
            {
                EditorGUILayout.PropertyField(clipSerializedObject.FindProperty("id"));
            }
            EditorGUILayout.PropertyField(clipSerializedObject.FindProperty("displayName"));
            EditorGUILayout.PropertyField(clipSerializedObject.FindProperty("speed"));
            EditorGUILayout.PropertyField(clipSerializedObject.FindProperty("defaultEndBehavior"));
            EditorGUILayout.LabelField("Frame Count", clip.FrameCount.ToString());
            EditorGUILayout.LabelField("Total Duration", clip.TotalDurationMs + " ms");
            EditorGUILayout.LabelField("Storage", AssetDatabase.IsSubAsset(clip) ? "Graph sub-asset" : "External .asset");
            var owners = FrameAnimationAssetReferenceIndex.FindGraphsReferencing(clip);
            if (!AssetDatabase.IsSubAsset(clip) && owners.Count > 1)
            {
                EditorGUILayout.HelpBox("共享外部 Manual Clip：" + string.Join(", ", owners.Select(owner => owner.name)), MessageType.Warning);
            }
            if (clip.IsImported)
            {
                EditorGUILayout.LabelField("Source Tag", clip.ImportInfo.SourceTagName);
                EditorGUILayout.LabelField("Missing", clip.ImportInfo.IsMissingFromSource ? "Yes" : "No");
            }
            else if (clip.HasStandaloneImportSource)
            {
                EditorGUILayout.LabelField("Source Tag",
                    string.IsNullOrEmpty(clip.StandaloneImportSource.LastImportedTagName)
                        ? "<all frames>"
                        : clip.StandaloneImportSource.LastImportedTagName);
                if (GUILayout.Button("Open Standalone Clip Editor"))
                {
                    FrameClipEditorWindow.Open(clip);
                }
            }
            if (clipSerializedObject.ApplyModifiedProperties())
            {
                EditorUtility.SetDirty(clip);
            }

            if (!clip.IsImported && !clip.HasStandaloneImportSource)
            {
                frameList.DoLayoutList();
                if (clipSerializedObject.ApplyModifiedProperties())
                {
                    EditorUtility.SetDirty(clip);
                }
                if (frameList.index >= 0 && GUILayout.Button("Duplicate Selected Frame"))
                {
                    DuplicateFrame(clipSerializedObject.FindProperty("frames"), frameList.index);
                    clipSerializedObject.ApplyModifiedProperties();
                    EditorUtility.SetDirty(clip);
                }
            }
            if (clip.IsImported)
            {
                using (new EditorGUI.DisabledScope(true))
                {
                    frameList.DoLayoutList();
                }
                if (GUILayout.Button("Locate ImportSource"))
                {
                    var source = graph.ImportSources.FirstOrDefault(item => item != null && item.InternalId == clip.ImportInfo.ImportSourceId);
                    SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Source, source));
                    SetResourceTab(ResourceTab.Sources);
                }
                if (GUILayout.Button("Copy As Manual Clip"))
                {
                    FrameAnimationManualClipWindow.Show(graph, clip, copied =>
                    {
                        RefreshBrowser();
                        SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Clip, copied));
                    });
                }
            }
            else if (clip.HasStandaloneImportSource)
            {
                using (new EditorGUI.DisabledScope(true))
                {
                    frameList.DoLayoutList();
                }
            }

            if (GUILayout.Button("Rename Clip ID"))
            {
                ShowRenameClip(clip);
            }
            if (GUILayout.Button("Locate Node References"))
            {
                LocateClipReferences(clip);
            }
            if (GUILayout.Button(AssetDatabase.IsSubAsset(clip) ? "Delete Clip Sub-Asset" : "Remove Clip Reference"))
            {
                ConfirmRemoveClip(clip);
            }
        }

        private void EnsureFrameList(FrameClip clip)
        {
            var editable = !clip.IsImported && !clip.HasStandaloneImportSource;
            if (frameListClip == clip && frameList != null && frameListEditable == editable)
            {
                return;
            }
            frameListClip = clip;
            frameListEditable = editable;
            clipSerializedObject = new SerializedObject(clip);
            var frames = clipSerializedObject.FindProperty("frames");
            frameList = new ReorderableList(clipSerializedObject, frames, editable, true, editable, editable)
            {
                elementHeight = 72f,
                drawHeaderCallback = rect => EditorGUI.LabelField(rect,
                    editable ? "Frames (frameName/sourceIndex are read-only)" : "Frames (source-managed, read-only)"),
                drawElementCallback = (rect, index, active, focused) => DrawFrameElement(frames, rect, index),
                onAddCallback = list => AddFrame(frames),
                onRemoveCallback = list =>
                {
                    ReorderableList.defaultBehaviours.DoRemoveButton(list);
                    clipSerializedObject.ApplyModifiedProperties();
                    EditorUtility.SetDirty(clip);
                },
                onReorderCallback = _ =>
                {
                    clipSerializedObject.ApplyModifiedProperties();
                    EditorUtility.SetDirty(clip);
                }
            };
        }

        private static void DrawFrameElement(SerializedProperty frames, Rect rect, int index)
        {
            if (index < 0 || index >= frames.arraySize)
            {
                return;
            }
            var element = frames.GetArrayElementAtIndex(index);
            rect.y += 2f;
            var line = EditorGUIUtility.singleLineHeight;
            EditorGUI.PropertyField(new Rect(rect.x, rect.y, rect.width, line), element.FindPropertyRelative("sprite"), new GUIContent($"#{index} Sprite"));
            EditorGUI.PropertyField(new Rect(rect.x, rect.y + line + 2f, rect.width, line), element.FindPropertyRelative("durationMs"));
            using (new EditorGUI.DisabledScope(true))
            {
                var half = (rect.width - 4f) * 0.5f;
                EditorGUI.PropertyField(new Rect(rect.x, rect.y + (line + 2f) * 2f, half, line), element.FindPropertyRelative("frameName"));
                EditorGUI.PropertyField(new Rect(rect.x + half + 4f, rect.y + (line + 2f) * 2f, half, line), element.FindPropertyRelative("sourceIndex"));
            }
        }

        private void AddFrame(SerializedProperty frames)
        {
            var index = frames.arraySize;
            frames.InsertArrayElementAtIndex(index);
            var element = frames.GetArrayElementAtIndex(index);
            element.FindPropertyRelative("sprite").objectReferenceValue = null;
            element.FindPropertyRelative("durationMs").intValue = 100;
            element.FindPropertyRelative("frameName").stringValue = string.Empty;
            element.FindPropertyRelative("sourceIndex").intValue = -1;
            clipSerializedObject.ApplyModifiedProperties();
            frameList.index = index;
            EditorUtility.SetDirty(frameListClip);
        }

        private static void DuplicateFrame(SerializedProperty frames, int index)
        {
            if (index >= 0 && index < frames.arraySize)
            {
                frames.InsertArrayElementAtIndex(index);
            }
        }

        private void DrawFlowProperties(AnimationFlow flow)
        {
            var index = graph.Flows.ToList().IndexOf(flow);
            if (index < 0)
            {
                EditorGUILayout.HelpBox("Flow 已失效。", MessageType.Warning);
                return;
            }
            var serialized = new SerializedObject(graph);
            serialized.Update();
            var property = serialized.FindProperty("flows").GetArrayElementAtIndex(index);
            EditorGUILayout.LabelField("Animation Flow", EditorStyles.boldLabel);
            using (new EditorGUI.DisabledScope(true))
            {
                EditorGUILayout.PropertyField(property.FindPropertyRelative("id"));
                EditorGUILayout.PropertyField(property.FindPropertyRelative("entryNodeId"));
            }
            EditorGUILayout.PropertyField(property.FindPropertyRelative("displayName"));
            EditorGUILayout.PropertyField(property.FindPropertyRelative("hasEndBehaviorOverride"));
            if (property.FindPropertyRelative("hasEndBehaviorOverride").boolValue)
            {
                EditorGUILayout.PropertyField(property.FindPropertyRelative("endBehaviorOverride"));
            }
            if (serialized.ApplyModifiedProperties())
            {
                EditorUtility.SetDirty(graph);
            }
            var flowData = graph.EditorData.FlowEditorData.FirstOrDefault(data => data != null && data.FlowId == flow.Id);
            var color = flowData?.Color ?? Color.white;
            var nextColor = EditorGUILayout.ColorField("Canvas Color", color);
            if (nextColor != color)
            {
                FrameAnimationGraphMutationService.SetFlowColor(graph, flow, nextColor);
                RefreshGraphView();
            }
            EditorGUILayout.LabelField("Entry Candidate",
                lastSelectedNode != null && graph.Nodes.Contains(lastSelectedNode)
                    ? $"{lastSelectedNode.DisplayName} ({lastSelectedNode.InternalId})"
                    : "<Select a Node on canvas>");
            using (new EditorGUI.DisabledScope(lastSelectedNode == null || !graph.Nodes.Contains(lastSelectedNode)))
            {
                if (GUILayout.Button("Set Selected Node As Entry"))
                {
                    if (!FrameAnimationGraphMutationService.SetFlowEntry(
                            graph, flow, lastSelectedNode, out var entryError))
                    {
                        EditorUtility.DisplayDialog("无法修改 Flow 入口", entryError, "确定");
                    }
                    else
                    {
                        EnterFlowFocus(flow.Id);
                        OnCanvasGraphChanged();
                    }
                }
            }
            if (GUILayout.Button("Focus Flow On Canvas"))
            {
                EnterFlowFocus(flow.Id);
                graphView?.FrameCurrentFlow(flow.Id);
            }
            if (GUILayout.Button("Rename Flow ID"))
            {
                ShowRenameFlow(flow);
            }
            if (GUILayout.Button("Delete Flow"))
            {
                if (!FrameAnimationAssetOperations.CanRemoveFlow(graph, flow, out var blocker))
                {
                    EditorUtility.DisplayDialog("无法删除 Flow", blocker, "确定");
                    return;
                }
                if (!EditorUtility.DisplayDialog(
                        "确认删除 Flow",
                        "只删除 Flow 定义，不会删除其 Node 或 Edge。是否继续？",
                        "删除",
                        "取消"))
                {
                    return;
                }
                if (!FrameAnimationAssetOperations.RemoveFlow(graph, flow, out var error))
                {
                    EditorUtility.DisplayDialog("无法删除 Flow", error, "确定");
                }
                else
                {
                    ExitFlowFocus(false);
                    SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Graph, graph));
                    OnCanvasGraphChanged();
                }
            }
        }

        private void DrawSourceProperties(FrameAnimationImportSource source)
        {
            var index = graph.ImportSources.ToList().IndexOf(source);
            if (index < 0)
            {
                EditorGUILayout.HelpBox("ImportSource 已失效。", MessageType.Warning);
                return;
            }
            var serialized = new SerializedObject(graph);
            serialized.Update();
            var property = serialized.FindProperty("importSources").GetArrayElementAtIndex(index);
            EditorGUILayout.LabelField("ImportSource", EditorStyles.boldLabel);
            using (new EditorGUI.DisabledScope(true))
            {
                EditorGUILayout.PropertyField(property.FindPropertyRelative("internalId"));
            }
            if (GUILayout.Button("Copy Internal ID"))
            {
                GUIUtility.systemCopyBuffer = source.InternalId;
            }
            EditorGUILayout.PropertyField(property.FindPropertyRelative("displayName"));
            EditorGUILayout.PropertyField(property.FindPropertyRelative("isEnabled"));
            EditorGUILayout.PropertyField(property.FindPropertyRelative("texture"));
            EditorGUILayout.PropertyField(property.FindPropertyRelative("asepriteJson"));
            EditorGUILayout.PropertyField(property.FindPropertyRelative("pivot"));
            EditorGUILayout.PropertyField(property.FindPropertyRelative("manageSpriteSlicing"));
            EditorGUILayout.PropertyField(property.FindPropertyRelative("defaultNewClipEndBehavior"));
            using (new EditorGUI.DisabledScope(true))
            {
                EditorGUILayout.PropertyField(property.FindPropertyRelative("lastSourceHash"));
            }
            if (serialized.ApplyModifiedProperties())
            {
                EditorUtility.SetDirty(graph);
            }
            var clipCount = graph.Clips.Count(clip => clip != null && clip.ImportInfo?.ImportSourceId == source.InternalId);
            EditorGUILayout.LabelField("Associated Clips", clipCount.ToString());
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("Preview Source"))
            {
                importPreview = FrameAnimationImportService.PreviewSource(graph, source.InternalId);
                SetBottomTab(BottomTab.ImportDiff);
            }
            if (GUILayout.Button("Refresh Source"))
            {
                importPreview = FrameAnimationImportService.PreviewSource(graph, source.InternalId);
                ApplyImportPreview();
            }
            EditorGUILayout.EndHorizontal();
            if (GUILayout.Button("Remove ImportSource"))
            {
                var associated = graph.Clips.Where(clip => clip != null &&
                    clip.ImportInfo?.ImportSourceId == source.InternalId).ToArray();
                if (associated.Length > 0)
                {
                    EditorUtility.DisplayDialog(
                        "无法删除 ImportSource",
                        "仍关联 Imported Clip：" + string.Join(", ", associated.Select(clip => clip.Id)),
                        "确定");
                }
                else if (EditorUtility.DisplayDialog(
                             "删除 ImportSource",
                             "该操作不会删除 Texture、JSON、Sprite 或 SpriteRect。确认删除来源？",
                             "删除",
                             "取消"))
                {
                    if (!FrameAnimationAssetOperations.RemoveSource(graph, source, out var error))
                    {
                        EditorUtility.DisplayDialog("无法删除 ImportSource", error, "确定");
                    }
                    else
                    {
                        SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Graph, graph));
                        RefreshBrowser();
                    }
                }
            }
        }

        private void DrawNodeProperties(AnimationNode node)
        {
            if (node == null)
            {
                EditorGUILayout.HelpBox("Node 已失效。", MessageType.Warning);
                return;
            }
            EditorGUILayout.LabelField("AnimationNode", EditorStyles.boldLabel);
            using (new EditorGUI.DisabledScope(true))
            {
                EditorGUILayout.TextField("Internal ID", node.InternalId);
            }
            if (GUILayout.Button("Copy Internal ID")) GUIUtility.systemCopyBuffer = node.InternalId;

            var nextName = EditorGUILayout.TextField("Display Name", node.DisplayName);
            if (nextName != node.DisplayName)
            {
                FrameAnimationGraphMutationService.SetNodeDisplayName(graph, node, nextName);
                OnCanvasGraphChanged();
            }

            var clips = graph.Clips.Where(clip => clip != null).ToList();
            var currentClip = clips.FindIndex(clip => clip.Id == node.ClipId);
            var labels = new List<string>();
            if (currentClip < 0)
            {
                labels.Add($"<Missing: {node.ClipId}>");
            }
            labels.AddRange(clips.Select(clip => $"{clip.DisplayName} ({clip.Id})"));
            var popupIndex = currentClip < 0 ? 0 : currentClip;
            var nextClipIndex = EditorGUILayout.Popup("Clip", popupIndex, labels.ToArray());
            if (nextClipIndex != popupIndex)
            {
                var selectedClip = clips[currentClip < 0 ? nextClipIndex - 1 : nextClipIndex];
                FrameAnimationGraphMutationService.SetNodeClip(graph, node, selectedClip);
                OnCanvasGraphChanged();
            }

            var hasSpeed = node.SpeedOverride.HasValue;
            var nextHasSpeed = EditorGUILayout.Toggle("Override Speed", hasSpeed);
            var speed = node.SpeedOverride ?? 1f;
            var nextSpeed = nextHasSpeed ? EditorGUILayout.FloatField("Speed", speed) : speed;
            if (nextHasSpeed != hasSpeed || nextHasSpeed && !Mathf.Approximately(nextSpeed, speed))
            {
                FrameAnimationGraphMutationService.SetNodeSpeed(graph, node, nextHasSpeed ? nextSpeed : (float?)null);
                OnCanvasGraphChanged();
            }

            var hasEnd = node.EndBehaviorOverride.HasValue;
            var nextHasEnd = EditorGUILayout.Toggle("Override End Behavior", hasEnd);
            var end = node.EndBehaviorOverride ?? FrameClipEndBehavior.HoldLastFrame;
            var nextEnd = nextHasEnd
                ? (FrameClipEndBehavior)EditorGUILayout.EnumPopup("End Behavior", end)
                : end;
            if (nextHasEnd != hasEnd || nextHasEnd && nextEnd != end)
            {
                var outgoing = graph.Edges.Where(edge => edge != null && edge.FromNodeId == node.InternalId).ToArray();
                var removeOutgoing = outgoing.Length == 0 || !nextHasEnd || EditorUtility.DisplayDialog(
                    "终点行为与后继冲突",
                    "该节点已有后继 Edge。设置结束行为会删除该 Edge，是否继续？",
                    "删除 Edge 并应用",
                    "取消");
                var error = string.Empty;
                if (removeOutgoing && FrameAnimationGraphMutationService.SetNodeEndBehavior(
                        graph, node, nextHasEnd ? nextEnd : (FrameClipEndBehavior?)null,
                        outgoing.Length > 0, out error))
                {
                    OnCanvasGraphChanged();
                }
                else if (!string.IsNullOrEmpty(error))
                {
                    EditorUtility.DisplayDialog("无法修改结束行为", error, "确定");
                }
            }

            var topology = new FrameAnimationGraphTopology(graph);
            var flows = topology.FindFlowsUsingNode(node.InternalId);
            EditorGUILayout.LabelField("Used By Flows", flows.Count == 0
                ? "None" : string.Join(", ", flows.Select(flow => flow.Id)));
            if (GUILayout.Button("Create Flow From Node")) ShowCreateFlow(node);
            if (GUILayout.Button("Delete Node")) graphView?.RequestDeleteNodes(new[] { node });
        }

        private void DrawEdgeProperties(AnimationEdge edge)
        {
            if (edge == null)
            {
                EditorGUILayout.HelpBox("Edge 已失效。", MessageType.Warning);
                return;
            }
            EditorGUILayout.LabelField("AnimationEdge", EditorStyles.boldLabel);
            EditorGUILayout.TextField("Internal ID", edge.InternalId);
            EditorGUILayout.TextField("From", edge.FromNodeId);
            EditorGUILayout.TextField("To", edge.ToNodeId);
            EditorGUILayout.TextField("Exit", edge.ExitName);
            EditorGUILayout.TextField("Condition", edge.Condition.ToString());
            if (GUILayout.Button("Disconnect Edge")) graphView?.RequestDeleteEdges(new[] { edge });
        }

        private void DrawBottomPanel()
        {
            if (bottomCollapsed)
            {
                return;
            }
            if (bottomTab == BottomTab.ImportDiff)
            {
                DrawImportDiff();
            }
            else
            {
                DrawValidation();
            }
        }

        private void DrawImportDiff()
        {
            if (importPreview == null)
            {
                EditorGUILayout.HelpBox("点击 Preview Imports 或来源 Preview 计算导入差异。", MessageType.Info);
                return;
            }
            foreach (var source in importPreview.Sources)
            {
                EditorGUILayout.LabelField(source.Source.DisplayName, EditorStyles.boldLabel);
                if (source.Document != null)
                {
                    var aliasCount = source.Document.Frames.Count - source.Document.SpriteSlots.Count;
                    EditorGUILayout.LabelField(
                        $"逻辑帧 {source.Document.Frames.Count} · SpriteSlot {source.Document.SpriteSlots.Count} · 共享别名 {aliasCount}",
                        EditorStyles.miniLabel);
                }
                if (GUILayout.Button("Locate Source", GUILayout.Width(110f)))
                {
                    SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Source, source.Source));
                    SetResourceTab(ResourceTab.Sources);
                }
                foreach (var issue in source.Issues)
                {
                    EditorGUILayout.HelpBox($"[{issue.Code}] {issue.Message}", issue.Severity == FrameAnimationValidationSeverity.Error
                        ? MessageType.Error : MessageType.Warning);
                }
                foreach (var group in source.ClipDiffs.GroupBy(diff => diff.Kind))
                {
                    EditorGUILayout.LabelField($"{group.Key} ({group.Count()})", EditorStyles.miniBoldLabel);
                    foreach (var diff in group)
                    {
                        EditorGUILayout.BeginHorizontal();
                        EditorGUILayout.LabelField($"{diff.SourceTagName}: {diff.Summary}");
                        if (diff.Clip != null && GUILayout.Button("Locate", GUILayout.Width(70f)))
                        {
                            SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Clip, diff.Clip));
                            SetResourceTab(ResourceTab.Clips);
                        }
                        EditorGUILayout.EndHorizontal();
                    }
                }
                if (source.SpriteDiffs.Count > 0)
                {
                    EditorGUILayout.LabelField("SpriteRect", EditorStyles.miniBoldLabel);
                    foreach (var group in source.SpriteDiffs.GroupBy(diff => diff.Kind))
                    {
                        EditorGUILayout.LabelField($"{group.Key} ({group.Count()})", EditorStyles.miniLabel);
                        foreach (var diff in group)
                        {
                            EditorGUILayout.LabelField($"  {diff.FrameName}: {diff.Summary}  {diff.Rect}",
                                EditorStyles.wordWrappedMiniLabel);
                        }
                    }
                }
            }
        }

        private void DrawValidation()
        {
            EditorGUILayout.BeginHorizontal();
            showErrors = GUILayout.Toggle(showErrors, "Errors", "Button");
            showWarnings = GUILayout.Toggle(showWarnings, "Warnings", "Button");
            showInfo = GUILayout.Toggle(showInfo, "Info", "Button");
            validationKindFilter = (ValidationKindFilter)EditorGUILayout.EnumPopup(
                validationKindFilter, GUILayout.Width(110f));
            EditorGUILayout.EndHorizontal();
            foreach (var issue in validationIssues.Where(ShowIssue))
            {
                EditorGUILayout.BeginVertical(EditorStyles.helpBox);
                EditorGUILayout.LabelField($"[{issue.Severity}] {issue.Code}", EditorStyles.boldLabel);
                EditorGUILayout.LabelField(issue.Message, EditorStyles.wordWrappedLabel);
                if (!string.IsNullOrEmpty(issue.Suggestion))
                {
                    EditorGUILayout.LabelField("建议：" + issue.Suggestion, EditorStyles.wordWrappedMiniLabel);
                }
                if (issue.Selection.Value != null && GUILayout.Button("Locate", GUILayout.Width(80f)))
                {
                    SetSelection(issue.Selection);
                    SetResourceTab(issue.Selection.Kind switch
                    {
                        FrameAnimationEditorSelectionKind.Clip => ResourceTab.Clips,
                        FrameAnimationEditorSelectionKind.Flow => ResourceTab.Flows,
                        FrameAnimationEditorSelectionKind.Source => ResourceTab.Sources,
                        _ => resourceTab
                    });
                }
                EditorGUILayout.EndVertical();
            }
        }

        private bool ShowIssue(FrameAnimationEditorIssue issue)
        {
            var severityVisible = issue.Severity switch
            {
                FrameAnimationValidationSeverity.Error => showErrors,
                FrameAnimationValidationSeverity.Warning => showWarnings,
                _ => showInfo
            };
            return severityVisible && (validationKindFilter == ValidationKindFilter.All ||
                validationKindFilter.ToString() == issue.Selection.Kind.ToString());
        }

        private void CreateGraph()
        {
            var path = EditorUtility.SaveFilePanelInProject(
                "Create FrameAnimationGraph", "FrameAnimationGraph", "asset", "请选择保存位置。");
            if (string.IsNullOrEmpty(path))
            {
                return;
            }
            var created = ScriptableObject.CreateInstance<FrameAnimationGraph>();
            var id = Path.GetFileNameWithoutExtension(path);
            created.Configure(id, id, Array.Empty<FrameClip>(), Array.Empty<AnimationNode>(),
                Array.Empty<AnimationEdge>(), Array.Empty<AnimationFlow>(), string.Empty);
            AssetDatabase.CreateAsset(created, path);
            Undo.RegisterCreatedObjectUndo(created, "Create FrameAnimationGraph");
            AssetDatabase.SaveAssets();
            SetGraph(created);
        }

        private void SaveGraph()
        {
            if (graph == null)
            {
                return;
            }
            clipSerializedObject?.ApplyModifiedProperties();
            EditorUtility.SetDirty(graph);
            AssetDatabase.SaveAssets();
            UpdateDirtyLabel();
        }

        private void UpdateDirtyLabel()
        {
            if (dirtyLabel == null)
            {
                return;
            }
            var dirty = graph != null && (EditorUtility.IsDirty(graph) || graph.Clips.Any(clip => clip != null && EditorUtility.IsDirty(clip)));
            dirtyLabel.text = graph == null ? "No Graph" : dirty ? "● Unsaved" : "Saved";
            dirtyLabel.style.color = dirty ? new StyleColor(new Color(1f, 0.65f, 0.2f)) : new StyleColor(Color.gray);
        }

        private void CreateManualClip()
        {
            if (graph == null)
            {
                return;
            }
            FrameAnimationManualClipWindow.Show(graph, null, clip =>
            {
                RefreshBrowser();
                SetResourceTab(ResourceTab.Clips);
                SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Clip, clip));
            });
        }

        private void AddExistingClip()
        {
            if (graph == null)
            {
                return;
            }
            FrameAnimationExistingClipWindow.Show(graph, clip =>
            {
                RefreshBrowser();
                SetResourceTab(ResourceTab.Clips);
                SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Clip, clip));
            });
        }

        private void AddSource()
        {
            if (graph == null)
            {
                return;
            }
            Undo.RecordObject(graph, "Add Frame Animation ImportSource");
            var source = new FrameAnimationImportSource();
            graph.AddImportSource(source);
            EditorUtility.SetDirty(graph);
            SetResourceTab(ResourceTab.Sources);
            RefreshBrowser();
            SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Source, source));
        }

        private void PreviewAllImports()
        {
            if (graph == null)
            {
                return;
            }
            importPreview = FrameAnimationImportService.PreviewAll(graph);
            SetBottomTab(BottomTab.ImportDiff);
            RefreshBottomPanel();
        }

        private void RefreshAllImports()
        {
            PreviewAllImports();
            ApplyImportPreview();
        }

        private void ApplyImportPreview()
        {
            if (importPreview == null || importPreview.HasErrors)
            {
                SetBottomTab(BottomTab.ImportDiff);
                return;
            }
            var allowSpriteChanges = !importPreview.HasSpriteChanges || EditorUtility.DisplayDialog(
                "确认修改 TextureImporter", BuildSpriteConfirmation(importPreview), "应用切图并刷新", "取消");
            if (!allowSpriteChanges)
            {
                return;
            }
            if (!FrameAnimationImportService.Apply(importPreview, allowSpriteChanges, out var error))
            {
                EditorUtility.DisplayDialog("刷新失败", error, "确定");
            }
            previewCoordinator.RefreshTarget(true);
            importPreview = FrameAnimationImportService.PreviewAll(graph);
            RefreshBrowser();
            ValidateFull();
        }

        private static string BuildSpriteConfirmation(FrameAnimationImportPreview preview)
        {
            var added = preview.Sources.Sum(source => source.SpriteDiffs.Count(diff => diff.Kind == FrameAnimationSpriteChangeKind.Added));
            var updated = preview.Sources.Sum(source => source.SpriteDiffs.Count(diff => diff.Kind == FrameAnimationSpriteChangeKind.Updated));
            var retained = preview.Sources.Sum(source => source.SpriteDiffs.Count(diff => diff.Kind == FrameAnimationSpriteChangeKind.Retained));
            return $"新增 SpriteRect：{added}\n更新 SpriteRect：{updated}\n保留旧 SpriteRect：{retained}\n\n是否继续？";
        }

        private void ValidateFull()
        {
            if (graph == null)
            {
                return;
            }
            validationIssues = FrameAnimationEditorValidationService.Validate(graph, true, out var validationPreview);
            if (validationPreview != null)
            {
                importPreview = validationPreview;
            }
            SetBottomTab(BottomTab.Validation);
            RefreshBottomPanel();
            RefreshBrowser();
            RefreshGraphView();
        }

        private void ScheduleLightValidation()
        {
            validateAt = EditorApplication.timeSinceStartup + 0.3d;
        }

        private void ShowRenameClip(FrameClip clip)
        {
            var refs = graph.Nodes.Count(node => node != null && node.ClipId == clip.Id);
            FrameAnimationTextInputWindow.Show(
                "Rename Clip ID", "New Clip ID", clip.Id,
                $"将更新 {refs} 个 Node 引用和匹配的 defaultPlayableId。外部字符串调用无法自动修复。",
                value => FrameAnimationAssetOperations.IsPlayableIdAvailable(graph, value, clip)
                    ? string.Empty : "ID 为空或与现有 Clip / Flow 冲突。",
                value =>
                {
                    if (!FrameAnimationAssetOperations.RenameClip(graph, clip, value, out var error))
                    {
                        EditorUtility.DisplayDialog("重命名失败", error, "确定");
                    }
                    RefreshBrowser();
                    RefreshGraphView();
                    ValidateFull();
                });
        }

        private void ShowRenameFlow(AnimationFlow flow)
        {
            var oldId = flow.Id;
            FrameAnimationTextInputWindow.Show(
                "Rename Flow ID", "New Flow ID", flow.Id,
                "将同步更新 defaultPlayableId 和 Flow EditorData；外部字符串调用无法自动修复。",
                value => FrameAnimationAssetOperations.IsPlayableIdAvailable(graph, value, exceptFlow: flow)
                    ? string.Empty : "ID 为空或与现有 Clip / Flow 冲突。",
                value =>
                {
                    if (!FrameAnimationAssetOperations.RenameFlow(graph, flow, value, out var error))
                    {
                        EditorUtility.DisplayDialog("重命名失败", error, "确定");
                    }
                    else if (focusedFlowId == oldId)
                    {
                        EnterFlowFocus(flow.Id);
                    }
                    RefreshBrowser();
                    RefreshFlowChoices();
                    RefreshGraphView();
                    ValidateFull();
                });
        }

        private void ShowRenameGraph()
        {
            FrameAnimationTextInputWindow.Show(
                "Rename Graph ID", "New Graph ID", graph.Id,
                "Graph id 可能被 Addressable key、资源查找或外部工具引用，无法自动迁移外部调用。",
                value => string.IsNullOrWhiteSpace(value) ? "Graph id 不能为空。" : string.Empty,
                value =>
                {
                    FrameAnimationAssetOperations.RenameGraph(graph, value, out _);
                    RefreshCanvasSummary();
                });
        }

        private void LocateClipReferences(FrameClip clip)
        {
            var nodes = graph.Nodes.Where(node => node != null && node.ClipId == clip.Id).ToArray();
            if (nodes.Length == 0)
            {
                EditorUtility.DisplayDialog("定位引用", "该 Clip 未被任何 Node 引用。", "确定");
                return;
            }
            if (nodes.Length == 1)
            {
                SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Node, nodes[0]));
                return;
            }
            var menu = new GenericMenu();
            foreach (var node in nodes)
            {
                var captured = node;
                menu.AddItem(new GUIContent($"{node.DisplayName}/{node.InternalId}"), false,
                    () => SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Node, captured)));
            }
            menu.ShowAsContext();
        }

        private void ConfirmRemoveClip(FrameClip clip)
        {
            if (!FrameAnimationAssetOperations.CanRemoveClip(graph, clip, out var blocker))
            {
                EditorUtility.DisplayDialog("无法移除 Clip", blocker, "确定");
                return;
            }
            var subAsset = AssetDatabase.IsSubAsset(clip);
            var message = subAsset
                ? "将从 Graph 移除并删除 Clip sub-asset。"
                : "只从当前 Graph 移除引用，不删除外部 .asset。";
            if (clip.IsImported && !clip.ImportInfo.IsMissingFromSource)
            {
                message += "\n\n源 Tag 仍存在时，下次刷新会重新创建 Imported Clip。";
            }
            if (!EditorUtility.DisplayDialog("确认移除 Clip", message, subAsset ? "删除" : "移除", "取消"))
            {
                return;
            }
            if (!FrameAnimationAssetOperations.RemoveClip(graph, clip, out var error))
            {
                EditorUtility.DisplayDialog("无法移除 Clip", error, "确定");
                return;
            }
            SetSelection(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Graph, graph));
            RefreshBrowser();
            ValidateFull();
        }

        private void ToggleBottom()
        {
            bottomCollapsed = !bottomCollapsed;
            ApplyBottomState();
            SaveWorkspaceState();
        }

        private void ApplyBottomState()
        {
            if (bottomPanel == null)
            {
                return;
            }
            bottomPanel.style.height = bottomCollapsed ? 31f : FrameAnimationWorkspaceState.GetFloat(graph, "BottomHeight", 210f);
            bottomContainer.style.display = bottomCollapsed ? DisplayStyle.None : DisplayStyle.Flex;
            if (bottomCollapseButton != null)
            {
                bottomCollapseButton.text = bottomCollapsed ? "▴" : "▾";
                bottomCollapseButton.tooltip = bottomCollapsed ? "Expand results" : "Collapse results";
            }
            RefreshBottomPanel();
        }

        private VisualElement CreateVerticalResizer(
            VisualElement panel,
            float min,
            float max,
            string stateName,
            bool resizeFromLeft = false)
        {
            var resizer = new VisualElement
            {
                style = { width = 4f }
            };
            resizer.AddToClassList("fa-resizer--vertical");
            float startWidth = 0f;
            float startX = 0f;
            resizer.RegisterCallback<PointerDownEvent>(evt =>
            {
                startWidth = panel.resolvedStyle.width;
                startX = evt.position.x;
                resizer.CapturePointer(evt.pointerId);
            });
            resizer.RegisterCallback<PointerMoveEvent>(evt =>
            {
                if (!resizer.HasPointerCapture(evt.pointerId)) return;
                var delta = evt.position.x - startX;
                panel.style.width = Mathf.Clamp(startWidth + (resizeFromLeft ? -delta : delta), min, max);
            });
            resizer.RegisterCallback<PointerUpEvent>(evt =>
            {
                if (resizer.HasPointerCapture(evt.pointerId)) resizer.ReleasePointer(evt.pointerId);
                FrameAnimationWorkspaceState.SetFloat(graph, stateName, panel.resolvedStyle.width);
            });
            return resizer;
        }

        private VisualElement CreateHorizontalResizer(VisualElement panel, float min, float max, string stateName)
        {
            var resizer = new VisualElement
            {
                style = { height = 4f }
            };
            resizer.AddToClassList("fa-resizer--horizontal");
            float startHeight = 0f;
            float startY = 0f;
            resizer.RegisterCallback<PointerDownEvent>(evt =>
            {
                startHeight = panel.resolvedStyle.height;
                startY = evt.position.y;
                resizer.CapturePointer(evt.pointerId);
            });
            resizer.RegisterCallback<PointerMoveEvent>(evt =>
            {
                if (!resizer.HasPointerCapture(evt.pointerId)) return;
                var delta = startY - evt.position.y;
                panel.style.height = Mathf.Clamp(startHeight + delta, min, max);
            });
            resizer.RegisterCallback<PointerUpEvent>(evt =>
            {
                if (resizer.HasPointerCapture(evt.pointerId)) resizer.ReleasePointer(evt.pointerId);
                FrameAnimationWorkspaceState.SetFloat(graph, stateName, panel.resolvedStyle.height);
            });
            return resizer;
        }

        private void RestoreWorkspaceState()
        {
            if (graph == null || leftPanel == null)
            {
                return;
            }
            resourceTab = Enum.TryParse(FrameAnimationWorkspaceState.GetString(graph, "ResourceTab", "Clips"), out ResourceTab restoredTab)
                ? restoredTab : ResourceTab.Clips;
            bottomTab = Enum.TryParse(FrameAnimationWorkspaceState.GetString(graph, "BottomTab", "Validation"), out BottomTab restoredBottom)
                ? restoredBottom : BottomTab.Validation;
            clipFilter = Enum.TryParse(FrameAnimationWorkspaceState.GetString(graph, "ClipFilter", "All"), out FrameAnimationClipFilter restoredFilter)
                ? restoredFilter : FrameAnimationClipFilter.All;
            clipSort = Enum.TryParse(FrameAnimationWorkspaceState.GetString(graph, "ClipSort", "Source"), out FrameAnimationClipSort restoredSort)
                ? restoredSort : FrameAnimationClipSort.Source;
            searchField.SetValueWithoutNotify(FrameAnimationWorkspaceState.GetString(graph, "Search", string.Empty));
            filterField.SetValueWithoutNotify(clipFilter);
            sortField.SetValueWithoutNotify(clipSort);
            leftPanel.style.width = FrameAnimationWorkspaceState.GetFloat(graph, "LeftWidth", 286f);
            rightPanel.style.width = FrameAnimationWorkspaceState.GetFloat(graph, "RightWidth", 338f);
            bottomCollapsed = FrameAnimationWorkspaceState.GetBool(graph, "BottomCollapsed", false);
            validationKindFilter = Enum.TryParse(
                FrameAnimationWorkspaceState.GetString(graph, "ValidationKind", "All"),
                out ValidationKindFilter restoredValidationKind)
                ? restoredValidationKind : ValidationKindFilter.All;
            var nodePolicy = Enum.TryParse(
                FrameAnimationWorkspaceState.GetString(graph, "NodePreviewPolicy", "SelectedOnly"),
                out NodePreviewPolicy restoredNodePolicy)
                ? restoredNodePolicy : NodePreviewPolicy.SelectedOnly;
            var background = Enum.TryParse(
                FrameAnimationWorkspaceState.GetString(graph, "PreviewBackground", "Checkerboard"),
                out FrameAnimationPreviewBackground restoredBackground)
                ? restoredBackground : FrameAnimationPreviewBackground.Checkerboard;
            var zoomMode = Enum.TryParse(
                FrameAnimationWorkspaceState.GetString(graph, "PreviewZoomMode", "Fit"),
                out FrameAnimationPreviewZoomMode restoredZoom)
                ? restoredZoom : FrameAnimationPreviewZoomMode.Fit;
            previewCoordinator.NodePolicy = nodePolicy;
            previewCoordinator.Background = background;
            previewCoordinator.ZoomMode = zoomMode;
            previewCoordinator.PreviewSpeed = Mathf.Clamp(
                FrameAnimationWorkspaceState.GetFloat(graph, "PreviewSpeed", 1f), 0.25f, 4f);
            previewCoordinator.ManualZoom = Mathf.Clamp(
                FrameAnimationWorkspaceState.GetFloat(graph, "PreviewManualZoom", 1f), 0.25f, 8f);
            bottomPanel.style.height = FrameAnimationWorkspaceState.GetFloat(graph, "BottomHeight", 210f);
            ApplyBottomState();
            RestoreCanvasView();
            RefreshPreviewUi();
        }

        private void RestoreCanvasView()
        {
            if (graph == null || graphView == null) return;
            var position = new Vector3(
                FrameAnimationWorkspaceState.GetFloat(graph, "CanvasX", 0f),
                FrameAnimationWorkspaceState.GetFloat(graph, "CanvasY", 0f),
                0f);
            var scale = FrameAnimationWorkspaceState.GetFloat(graph, "CanvasScale", 1f);
            graphView.RestoreViewTransform(position, scale);
        }

        private void RestoreSelection()
        {
            if (graph == null)
            {
                selection = default;
                return;
            }

            if (!Enum.TryParse(
                    FrameAnimationWorkspaceState.GetString(graph, "SelectionKind", "Graph"),
                    out FrameAnimationEditorSelectionKind kind))
            {
                kind = FrameAnimationEditorSelectionKind.Graph;
            }
            var id = FrameAnimationWorkspaceState.GetString(graph, "SelectionId", string.Empty);
            object value = kind switch
            {
                FrameAnimationEditorSelectionKind.Graph => graph,
                FrameAnimationEditorSelectionKind.Clip => ResolveClipSelection(id),
                FrameAnimationEditorSelectionKind.Flow => graph.Flows.FirstOrDefault(item => item != null && item.Id == id),
                FrameAnimationEditorSelectionKind.Source => graph.ImportSources.FirstOrDefault(item => item != null && item.InternalId == id),
                FrameAnimationEditorSelectionKind.Node => graph.Nodes.FirstOrDefault(item => item != null && item.InternalId == id),
                FrameAnimationEditorSelectionKind.Edge => graph.Edges.FirstOrDefault(item => item != null && item.InternalId == id),
                _ => null
            };
            selection = value != null
                ? new FrameAnimationEditorSelection(kind, value)
                : new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Graph, graph);
        }

        private FrameClip ResolveClipSelection(string globalId)
        {
            if (!string.IsNullOrEmpty(globalId) && GlobalObjectId.TryParse(globalId, out var parsed))
            {
                var clip = GlobalObjectId.GlobalObjectIdentifierToObjectSlow(parsed) as FrameClip;
                if (clip != null && graph.Clips.Contains(clip))
                {
                    return clip;
                }
            }
            return null;
        }

        private string GetSelectionId()
        {
            return selection.Kind switch
            {
                FrameAnimationEditorSelectionKind.Clip when selection.Value is FrameClip clip =>
                    GlobalObjectId.GetGlobalObjectIdSlow(clip).ToString(),
                FrameAnimationEditorSelectionKind.Flow when selection.Value is AnimationFlow flow => flow.Id,
                FrameAnimationEditorSelectionKind.Source when selection.Value is FrameAnimationImportSource source => source.InternalId,
                FrameAnimationEditorSelectionKind.Node when selection.Value is AnimationNode node => node.InternalId,
                FrameAnimationEditorSelectionKind.Edge when selection.Value is AnimationEdge edge => edge.InternalId,
                _ => string.Empty
            };
        }

        private void SaveWorkspaceState()
        {
            if (graph == null)
            {
                return;
            }
            FrameAnimationWorkspaceState.SetString(graph, "ResourceTab", resourceTab.ToString());
            FrameAnimationWorkspaceState.SetString(graph, "BottomTab", bottomTab.ToString());
            FrameAnimationWorkspaceState.SetString(graph, "ClipFilter", clipFilter.ToString());
            FrameAnimationWorkspaceState.SetString(graph, "ClipSort", clipSort.ToString());
            FrameAnimationWorkspaceState.SetString(graph, "Search", searchField?.value ?? string.Empty);
            FrameAnimationWorkspaceState.SetBool(graph, "BottomCollapsed", bottomCollapsed);
            FrameAnimationWorkspaceState.SetString(graph, "ValidationKind", validationKindFilter.ToString());
            FrameAnimationWorkspaceState.SetString(graph, "SelectionKind", selection.Kind.ToString());
            FrameAnimationWorkspaceState.SetString(graph, "SelectionId", GetSelectionId());
            FrameAnimationWorkspaceState.SetString(graph, "NodePreviewPolicy", previewCoordinator.NodePolicy.ToString());
            FrameAnimationWorkspaceState.SetString(graph, "PreviewBackground", previewCoordinator.Background.ToString());
            FrameAnimationWorkspaceState.SetString(graph, "PreviewZoomMode", previewCoordinator.ZoomMode.ToString());
            FrameAnimationWorkspaceState.SetFloat(graph, "PreviewSpeed", previewCoordinator.PreviewSpeed);
            FrameAnimationWorkspaceState.SetFloat(graph, "PreviewManualZoom", previewCoordinator.ManualZoom);
        }

        private void OnProjectDataChanged()
        {
            previewCoordinator.RefreshTarget(true);
            if (graph == null)
            {
                RestoreLastGraph();
            }
            if (graph != null)
            {
                var previouslySelectedFlow = selection.Value as AnimationFlow;
                RestoreSelection();
                if (previouslySelectedFlow != null && graph.Flows.Contains(previouslySelectedFlow))
                {
                    selection = new FrameAnimationEditorSelection(
                        FrameAnimationEditorSelectionKind.Flow, previouslySelectedFlow);
                }
                lastSelectedNode = selection.Value as AnimationNode;
                RevalidateFlowFocus();
            }
            RefreshBrowser();
            RefreshFlowChoices();
            RefreshGraphView();
            RefreshInspector();
            RefreshBottomPanel();
            RefreshCanvasSummary();
        }
    }

    internal static class FrameAnimationGraphAssetOpenHandler
    {
        [OnOpenAsset]
        private static bool OnOpenAsset(int instanceId, int line)
        {
            var asset = EditorUtility.InstanceIDToObject(instanceId);
            if (asset is FrameAnimationGraph graph)
            {
                FrameAnimationGraphEditorWindow.Open(graph);
                return true;
            }
            if (asset is FrameClip clip)
            {
                if (!AssetDatabase.IsSubAsset(clip))
                {
                    FrameClipEditorWindow.Open(clip);
                    return true;
                }
                var owners = FrameAnimationAssetReferenceIndex.FindGraphsReferencing(clip);
                if (owners.Count == 1)
                {
                    FrameAnimationGraphEditorWindow.Open(owners[0]);
                    return true;
                }
            }
            return false;
        }
    }
}