using System;
using System.Collections.Generic;
using System.Linq;
using UnityEditor;
using UnityEditor.Experimental.GraphView;
using UnityEngine;
using UnityEngine.UIElements;

namespace AibisDream.FrameAnimation.Editor
{
    internal sealed class FrameAnimationClipNodeView : Node
    {
        private readonly Label subtitle;
        private readonly Label behavior;
        private readonly Label issueBadge;
        private readonly Label entryBadge;
        private readonly VisualElement badgeContainer;
        private readonly FrameAnimationPreviewElement preview;
        private readonly Action<FrameAnimationClipNodeView> selectedCallback;
        private FrameAnimationFlowColorPalette? entryPalette;

        public AnimationNode Data { get; }
        public Port InputPort { get; }
        public Port OutputPort { get; }

        internal FrameAnimationClipNodeView(
            AnimationNode data,
            Action<FrameAnimationClipNodeView> selectedCallback)
        {
            Data = data;
            this.selectedCallback = selectedCallback;
            viewDataKey = data.InternalId;
            AddToClassList("fa-node");

            InputPort = Port.Create<Edge>(Orientation.Horizontal, Direction.Input, Port.Capacity.Multi,
                typeof(AnimationNode));
            InputPort.portName = string.Empty;
            inputContainer.Add(InputPort);
            OutputPort = Port.Create<Edge>(Orientation.Horizontal, Direction.Output, Port.Capacity.Single,
                typeof(AnimationNode));
            OutputPort.portName = string.Empty;
            outputContainer.Add(OutputPort);

            subtitle = new Label();
            subtitle.AddToClassList("fa-node__clip-id");
            behavior = new Label();
            behavior.AddToClassList("fa-node__behavior");
            var meta = new VisualElement();
            meta.AddToClassList("fa-node__meta");
            meta.Add(subtitle);
            meta.Add(behavior);
            extensionContainer.Add(meta);

            preview = new FrameAnimationPreviewElement();
            preview.AddToClassList("fa-node__preview");
            extensionContainer.Add(preview);

            badgeContainer = new VisualElement();
            badgeContainer.AddToClassList("fa-node__badges");
            entryBadge = new Label("E") { tooltip = "Flow Entry" };
            entryBadge.AddToClassList("fa-node__entry");
            badgeContainer.Add(entryBadge);
            issueBadge = new Label();
            issueBadge.AddToClassList("fa-badge");
            issueBadge.style.unityFontStyleAndWeight = FontStyle.Bold;
            badgeContainer.Add(issueBadge);
            extensionContainer.Add(badgeContainer);
            RefreshExpandedState();
        }

        public override void OnSelected()
        {
            base.OnSelected();
            selectedCallback?.Invoke(this);
        }

        internal void Refresh(
            FrameAnimationGraph graph,
            IReadOnlyList<FrameAnimationEditorIssue> issues,
            IReadOnlyList<AnimationFlow> flows)
        {
            var clip = graph.Clips.FirstOrDefault(item => item != null && item.Id == Data.ClipId);
            title = string.IsNullOrWhiteSpace(Data.DisplayName) ? Data.ClipId : Data.DisplayName;
            subtitle.text = clip != null ? Data.ClipId : $"Missing: {Data.ClipId}";
            var speed = Data.SpeedOverride.HasValue
                ? $"Speed {Data.SpeedOverride.Value:0.###} (Node)"
                : clip != null ? $"Speed {clip.Speed:0.###} (Clip)" : "Speed ?";
            var end = Data.EndBehaviorOverride?.ToString() ?? "Continue / terminal fallback";
            behavior.text = $"{speed} · {end}";
            var used = flows.Where(flow => flow != null).ToArray();
            var entryFlows = used.Where(flow => flow.EntryNodeId == Data.InternalId).ToArray();
            entryPalette = entryFlows.Length > 0
                ? FrameAnimationFlowColorUtility.CreatePalette(
                    FrameAnimationFlowColorUtility.ResolveRaw(graph, entryFlows[0]))
                : (FrameAnimationFlowColorPalette?)null;
            entryBadge.style.display = entryPalette.HasValue ? DisplayStyle.Flex : DisplayStyle.None;
            if (entryPalette.HasValue)
            {
                entryBadge.style.backgroundColor = entryPalette.Value.Stroke;
                entryBadge.style.color = entryPalette.Value.Text;
                entryBadge.tooltip = "Flow Entry: " + string.Join(", ", entryFlows.Select(flow => flow.Id));
            }

            foreach (var label in badgeContainer.Query<Label>(className: "fa-flow-badge").ToList())
            {
                label.RemoveFromHierarchy();
            }
            if (used.Length == 0)
            {
                var unused = new Label("UNUSED");
                unused.AddToClassList("fa-badge");
                unused.AddToClassList("fa-badge--yellow");
                unused.AddToClassList("fa-flow-badge");
                badgeContainer.Insert(entryPalette.HasValue ? 1 : 0, unused);
            }
            else
            {
                var insertIndex = entryPalette.HasValue ? 1 : 0;
                foreach (var flow in used.Take(3))
                {
                    var palette = FrameAnimationFlowColorUtility.CreatePalette(
                        FrameAnimationFlowColorUtility.ResolveRaw(graph, flow));
                    var badge = new Label(flow.Id) { tooltip = FlowTooltip(flow) };
                    badge.AddToClassList("fa-badge");
                    badge.AddToClassList("fa-flow-badge");
                    badge.style.backgroundColor = palette.Muted;
                    badge.style.color = palette.Text;
                    badgeContainer.Insert(insertIndex++, badge);
                }
            }
            var matching = issues.Where(issue => issue.Selection.Kind == FrameAnimationEditorSelectionKind.Node &&
                ReferenceEquals(issue.Selection.Value, Data)).ToArray();
            issueBadge.text = matching.Any(issue => issue.Severity == FrameAnimationValidationSeverity.Error)
                ? "ERROR"
                : matching.Length > 0 ? "WARNING" : string.Empty;
            issueBadge.style.display = matching.Length > 0 ? DisplayStyle.Flex : DisplayStyle.None;
            issueBadge.EnableInClassList("fa-badge--red",
                matching.Any(issue => issue.Severity == FrameAnimationValidationSeverity.Error));
            issueBadge.EnableInClassList("fa-badge--yellow",
                matching.Length > 0 && matching.All(issue => issue.Severity != FrameAnimationValidationSeverity.Error));
            issueBadge.style.color = matching.Any(issue => issue.Severity == FrameAnimationValidationSeverity.Error)
                ? new StyleColor(new Color(1f, 0.35f, 0.3f))
                : new StyleColor(new Color(1f, 0.72f, 0.25f));
            OutputPort.SetEnabled(!Data.EndBehaviorOverride.HasValue);
            OutputPort.tooltip = Data.EndBehaviorOverride.HasValue
                ? "该节点已设置终点结束行为，请先清除覆盖。"
                : "创建唯一的顺序后继";
        }

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

        internal void SetFocusedFlow(FrameAnimationGraph graph, AnimationFlow flow, bool belongs)
        {
            EnableInClassList("fa-node--focused", flow != null && belongs);
            if (flow != null && belongs)
            {
                var palette = FrameAnimationFlowColorUtility.CreatePalette(
                    FrameAnimationFlowColorUtility.ResolveRaw(graph, flow));
                titleContainer.style.backgroundColor = palette.Header;
                var titleLabel = titleContainer.Q<Label>(className: "title-label");
                if (titleLabel != null) titleLabel.style.color = palette.Text;
                style.borderLeftColor = palette.Stroke;
            }
            else
            {
                titleContainer.style.backgroundColor = StyleKeyword.Null;
                var titleLabel = titleContainer.Q<Label>(className: "title-label");
                if (titleLabel != null) titleLabel.style.color = StyleKeyword.Null;
                style.borderLeftColor = StyleKeyword.Null;
            }
        }

        internal void SetDimmed(bool dimmed)
        {
            style.opacity = dimmed ? 0.45f : 1f;
        }

        internal void SetPreview(
            FrameAnimationPreviewDisplay display,
            FrameAnimationPreviewBackground background)
        {
            preview.SetBackground(background);
            preview.SetZoom(FrameAnimationPreviewZoomMode.Fit, 1f);
            preview.SetDisplay(display.Sprite, display.IsEmpty);
            preview.style.opacity = display.FlowState == FrameAnimationFlowElementState.Upcoming
                ? 0.55f : display.FlowState == FrameAnimationFlowElementState.Passed ? 0.82f : 1f;
            EnableInClassList("fa-node--preview-current", display.FlowState == FrameAnimationFlowElementState.Current);
            EnableInClassList("fa-node--preview-passed", display.FlowState == FrameAnimationFlowElementState.Passed);
            EnableInClassList("fa-node--preview-upcoming", display.FlowState == FrameAnimationFlowElementState.Upcoming);
        }
    }

    internal sealed class FrameAnimationEdgeView : Edge
    {
        private readonly Action<FrameAnimationEdgeView> selectedCallback;
        private Color baseColor = new Color32(119, 127, 135, 255);
        private bool hasError;
        private bool hasWarning;
        private FrameAnimationFlowElementState previewState;
        public AnimationEdge Data { get; }

        internal FrameAnimationEdgeView(AnimationEdge data, Action<FrameAnimationEdgeView> selectedCallback)
        {
            Data = data;
            this.selectedCallback = selectedCallback;
            viewDataKey = data.InternalId;
            userData = data;
            RegisterCallback<AttachToPanelEvent>(_ => ApplyVisualState());
        }

        public override void OnSelected()
        {
            base.OnSelected();
            selectedCallback?.Invoke(this);
        }

        internal void SetDimmed(bool dimmed)
        {
            style.opacity = dimmed ? 0.30f : 1f;
        }

        internal void Refresh(IReadOnlyList<FrameAnimationEditorIssue> issues)
        {
            var matching = (issues ?? Array.Empty<FrameAnimationEditorIssue>()).Where(issue =>
                issue.Selection.Kind == FrameAnimationEditorSelectionKind.Edge &&
                ReferenceEquals(issue.Selection.Value, Data)).ToArray();
            hasError = matching.Any(issue => issue.Severity == FrameAnimationValidationSeverity.Error);
            hasWarning = !hasError && matching.Length > 0;
            ApplyVisualState();
            tooltip = matching.Length == 0
                ? $"{Data.ExitName} / {Data.Condition}"
                : string.Join("\n", matching.Select(issue => $"[{issue.Code}] {issue.Message}"));
        }

        internal void SetPreviewState(FrameAnimationFlowElementState state)
        {
            previewState = state;
            ApplyVisualState();
        }

        internal void SetFocusedFlow(Color? flowColor, bool belongs)
        {
            baseColor = flowColor.HasValue && belongs
                ? FrameAnimationFlowColorUtility.CreatePalette(flowColor.Value).Stroke
                : new Color32(119, 127, 135, 255);
            ApplyVisualState();
        }

        private void ApplyVisualState()
        {
            var color = hasError
                ? new Color32(223, 106, 106, 255)
                : hasWarning ? new Color32(224, 184, 88, 255) : baseColor;
            var width = 3f;
            if (!hasError && !hasWarning)
            {
                if (previewState == FrameAnimationFlowElementState.Current)
                {
                    color = Color.Lerp(color, Color.white, 0.28f);
                    width = 5f;
                }
                else if (previewState == FrameAnimationFlowElementState.Passed)
                {
                    color = Color.Lerp(color, new Color32(86, 185, 123, 255), 0.22f);
                    width = 3.5f;
                }
                else if (previewState == FrameAnimationFlowElementState.Upcoming)
                {
                    color = Color.Lerp(color, new Color32(43, 47, 52, 255), 0.42f);
                    width = 2f;
                }
            }
            edgeControl.inputColor = color;
            edgeControl.outputColor = color;
            if (panel != null)
            {
                edgeControl.edgeWidth = Mathf.RoundToInt(width);
            }
        }
    }

    internal sealed class FrameAnimationClipSearchProvider : ScriptableObject, ISearchWindowProvider
    {
        private FrameAnimationGraph graph;
        private Action<FrameClip> selected;

        internal void Configure(FrameAnimationGraph value, Action<FrameClip> callback)
        {
            graph = value;
            selected = callback;
        }

        public List<SearchTreeEntry> CreateSearchTree(SearchWindowContext context)
        {
            var entries = new List<SearchTreeEntry>
            {
                new SearchTreeGroupEntry(new GUIContent("Create Clip Node"), 0)
            };
            foreach (var clip in graph.Clips.Where(clip => clip != null)
                         .OrderBy(clip => clip.DisplayName, StringComparer.Ordinal)
                         .ThenBy(clip => clip.Id, StringComparer.Ordinal))
            {
                entries.Add(new SearchTreeEntry(new GUIContent($"{clip.DisplayName} ({clip.Id})"))
                {
                    level = 1,
                    userData = clip
                });
            }
            return entries;
        }

        public bool OnSelectEntry(SearchTreeEntry entry, SearchWindowContext context)
        {
            if (entry.userData is FrameClip clip)
            {
                selected?.Invoke(clip);
                return true;
            }
            return false;
        }
    }

    internal sealed class FrameAnimationGraphView : GraphView
    {
        internal const string ClipDragKey = "AibisDream.FrameAnimation.ClipDrag";

        private readonly Dictionary<string, FrameAnimationClipNodeView> nodeViews =
            new Dictionary<string, FrameAnimationClipNodeView>();
        private readonly Dictionary<string, FrameAnimationEdgeView> edgeViews =
            new Dictionary<string, FrameAnimationEdgeView>();
        private FrameAnimationGraph graph;
        private IReadOnlyList<FrameAnimationEditorIssue> issues = Array.Empty<FrameAnimationEditorIssue>();
        private bool rebuilding;
        private Vector2 contextPosition;
        private string focusedFlowId = string.Empty;

        internal event Action<FrameAnimationEditorSelection> SelectionRequested;
        internal event Action<IReadOnlyList<AnimationNode>> MultiSelectionChanged;
        internal event Action<IReadOnlyList<FrameAnimationEditorSelection>> SelectionSetChanged;
        internal event Action<AnimationNode> CreateFlowRequested;
        internal event Action<AnimationNode> NodeCreated;
        internal event Action ExitFocusRequested;
        internal event Action GraphChanged;
        internal event Action<string> NotificationRequested;
        internal event Action<Vector3, float> WorkspaceViewTransformChanged;

        internal FrameAnimationGraphView()
        {
            style.flexGrow = 1f;
            focusable = true;
            SetupZoom(ContentZoomer.DefaultMinScale, ContentZoomer.DefaultMaxScale);
            this.AddManipulator(new ContentDragger());
            this.AddManipulator(new SelectionDragger());
            this.AddManipulator(new RectangleSelector());
            var grid = new GridBackground();
            Insert(0, grid);
            grid.StretchToParentSize();
            graphViewChanged = OnGraphViewChanged;
            viewTransformChanged += _ =>
                WorkspaceViewTransformChanged?.Invoke(viewTransform.position, viewTransform.scale.x);
            RegisterCallback<MouseUpEvent>(_ => NotifySelectionSummary());
            RegisterCallback<DragUpdatedEvent>(OnDragUpdated);
            RegisterCallback<DragPerformEvent>(OnDragPerform);
            RegisterCallback<KeyDownEvent>(OnKeyDown);
        }

        internal void Bind(
            FrameAnimationGraph value,
            IReadOnlyList<FrameAnimationEditorIssue> validationIssues,
            string focusedFlowId)
        {
            graph = value;
            issues = validationIssues ?? Array.Empty<FrameAnimationEditorIssue>();
            var selectedIds = selection.OfType<FrameAnimationClipNodeView>()
                .Select(view => view.Data.InternalId).ToArray();
            var selectedEdgeIds = selection.OfType<FrameAnimationEdgeView>()
                .Select(view => view.Data.InternalId).ToArray();
            rebuilding = true;
            DeleteElements(graphElements.ToList());
            nodeViews.Clear();
            edgeViews.Clear();
            if (graph != null)
            {
                var topology = new FrameAnimationGraphTopology(graph);
                foreach (var node in graph.Nodes.Where(node => node != null))
                {
                    var view = new FrameAnimationClipNodeView(node, OnNodeSelected);
                    view.SetPosition(new Rect(FrameAnimationGraphMutationService.GetNodePosition(graph, node),
                        new Vector2(224f, 164f)));
                    view.Refresh(graph, issues, topology.FindFlowsUsingNode(node.InternalId));
                    nodeViews[node.InternalId] = view;
                    AddElement(view);
                }
                foreach (var edge in graph.Edges.Where(edge => edge != null))
                {
                    if (!nodeViews.TryGetValue(edge.FromNodeId ?? string.Empty, out var from) ||
                        !nodeViews.TryGetValue(edge.ToNodeId ?? string.Empty, out var to))
                    {
                        continue;
                    }
                    var view = new FrameAnimationEdgeView(edge, OnEdgeSelected)
                    {
                        output = from.OutputPort,
                        input = to.InputPort
                    };
                    view.output.Connect(view);
                    view.input.Connect(view);
                    view.Refresh(issues);
                    edgeViews[edge.InternalId] = view;
                    AddElement(view);
                }
                foreach (var id in selectedIds.Where(nodeViews.ContainsKey))
                {
                    AddToSelection(nodeViews[id]);
                }
                foreach (var id in selectedEdgeIds.Where(edgeViews.ContainsKey))
                {
                    AddToSelection(edgeViews[id]);
                }
            }
            rebuilding = false;
            SetFocusedFlow(focusedFlowId);
        }

        public override void BuildContextualMenu(ContextualMenuPopulateEvent evt)
        {
            if (evt.target == this || evt.target == contentViewContainer)
            {
                contextPosition = contentViewContainer.WorldToLocal(evt.mousePosition);
                evt.menu.AppendAction("Create Clip Node", _ => OpenClipSearch(evt.mousePosition),
                    graph != null && graph.Clips.Any(clip => clip != null)
                        ? DropdownMenuAction.Status.Normal : DropdownMenuAction.Status.Disabled);
            }
            if (selection.Count == 1 && selection[0] is FrameAnimationClipNodeView nodeView)
            {
                evt.menu.AppendAction("Create Flow From Node", _ => CreateFlowRequested?.Invoke(nodeView.Data));
            }
            base.BuildContextualMenu(evt);
        }

        public override List<Port> GetCompatiblePorts(Port startPort, NodeAdapter nodeAdapter)
        {
            var result = new List<Port>();
            if (graph == null || !(startPort.node is FrameAnimationClipNodeView startNode))
            {
                return result;
            }
            ports.ForEach(port =>
            {
                if (!(port.node is FrameAnimationClipNodeView targetNode) || port.direction == startPort.direction ||
                    targetNode == startNode)
                {
                    return;
                }
                var from = startPort.direction == Direction.Output ? startNode.Data : targetNode.Data;
                var to = startPort.direction == Direction.Output ? targetNode.Data : startNode.Data;
                if (FrameAnimationGraphMutationService.CanConnect(graph, from, to, out _))
                {
                    result.Add(port);
                }
            });
            return result;
        }

        internal void SetFocusedFlow(string flowId)
        {
            focusedFlowId = flowId ?? string.Empty;
            if (graph == null || string.IsNullOrEmpty(flowId))
            {
                foreach (var view in nodeViews.Values)
                {
                    view.SetDimmed(false);
                    view.SetFocusedFlow(graph, null, false);
                }
                foreach (var view in edgeViews.Values)
                {
                    view.SetDimmed(false);
                    view.SetFocusedFlow(null, false);
                }
                return;
            }
            var flow = graph.Flows.FirstOrDefault(item => item != null && item.Id == flowId);
            var topology = new FrameAnimationGraphTopology(graph);
            var reachable = flow != null
                ? topology.GetReachable(flow.EntryNodeId)
                : new FrameAnimationReachability(Array.Empty<AnimationNode>(), Array.Empty<AnimationEdge>());
            var nodeIds = new HashSet<string>(reachable.Nodes.Select(node => node.InternalId));
            var edgeIds = new HashSet<string>(reachable.Edges.Select(edge => edge.InternalId));
            var flowColor = flow != null ? FrameAnimationFlowColorUtility.ResolveRaw(graph, flow) : (Color?)null;
            foreach (var pair in nodeViews)
            {
                var belongs = nodeIds.Contains(pair.Key);
                pair.Value.SetDimmed(!belongs);
                pair.Value.SetFocusedFlow(graph, flow, belongs);
            }
            foreach (var pair in edgeViews)
            {
                var belongs = edgeIds.Contains(pair.Key);
                pair.Value.SetDimmed(!belongs);
                pair.Value.SetFocusedFlow(flowColor, belongs);
            }
        }

        internal void SelectAndFrame(FrameAnimationEditorSelection target)
        {
            GraphElement element = target.Value switch
            {
                AnimationNode node when nodeViews.TryGetValue(node.InternalId, out var nodeView) => nodeView,
                AnimationEdge edge when edgeViews.TryGetValue(edge.InternalId, out var edgeView) => edgeView,
                _ => null
            };
            if (element == null) return;
            ClearSelection();
            AddToSelection(element);
            FrameSelection();
        }

        internal IReadOnlyList<AnimationNode> SelectedNodes =>
            selection.OfType<FrameAnimationClipNodeView>().Select(view => view.Data).ToArray();

        internal IReadOnlyList<AnimationNode> VisibleNodes => nodeViews.Values
            .Where(view => view.worldBound.Overlaps(worldBound))
            .Select(view => view.Data)
            .ToArray();

        internal void ApplyPreview(FrameAnimationPreviewCoordinator coordinator)
        {
            if (coordinator == null) return;
            foreach (var view in nodeViews.Values)
            {
                view.SetPreview(coordinator.GetNodeDisplay(view.Data), coordinator.Background);
            }
            foreach (var view in edgeViews.Values)
            {
                view.SetPreviewState(coordinator.GetEdgeState(view.Data));
            }
        }

        internal void RestoreViewTransform(Vector3 position, float scale)
        {
            var safeScale = float.IsNaN(scale) || float.IsInfinity(scale)
                ? 1f : Mathf.Clamp(scale, ContentZoomer.DefaultMinScale, ContentZoomer.DefaultMaxScale);
            if (float.IsNaN(position.x) || float.IsInfinity(position.x) ||
                float.IsNaN(position.y) || float.IsInfinity(position.y))
            {
                position = Vector3.zero;
            }
            UpdateViewTransform(position, new Vector3(safeScale, safeScale, 1f));
        }

        internal void RequestDeleteNodes(IEnumerable<AnimationNode> nodes)
        {
            var items = (nodes ?? Array.Empty<AnimationNode>()).Where(node => node != null).Distinct().ToArray();
            if (graph == null || items.Length == 0)
            {
                return;
            }
            var ids = new HashSet<string>(items.Select(node => node.InternalId));
            var entryFlows = graph.Flows.Where(flow => flow != null && ids.Contains(flow.EntryNodeId)).ToArray();
            var impact = FrameAnimationGraphImpactAnalyzer.AnalyzeNodeRemoval(graph, items);
            if (!EditorUtility.DisplayDialog(
                    "Delete Frame Animation Nodes",
                    BuildRemovalMessage("Node", items.Length, impact, entryFlows),
                    entryFlows.Length > 0 ? "Delete Nodes + Flows" : "Delete",
                    "Cancel"))
            {
                return;
            }
            if (!FrameAnimationGraphMutationService.RemoveNodes(graph, items, entryFlows.Length > 0, out var error))
            {
                NotificationRequested?.Invoke(error);
                return;
            }
            GraphChanged?.Invoke();
        }

        internal void RequestDeleteEdges(IEnumerable<AnimationEdge> edges)
        {
            var items = (edges ?? Array.Empty<AnimationEdge>()).Where(edge => edge != null).Distinct().ToArray();
            if (graph == null || items.Length == 0)
            {
                return;
            }
            var impact = FrameAnimationGraphImpactAnalyzer.AnalyzeEdgeRemoval(graph, items);
            if (impact.Flows.Count > 0 && !EditorUtility.DisplayDialog(
                    "Disconnect Frame Animation Nodes",
                    BuildRemovalMessage("Edge", items.Length, impact, Array.Empty<AnimationFlow>()),
                    "Disconnect",
                    "Cancel"))
            {
                return;
            }
            FrameAnimationGraphMutationService.RemoveEdges(graph, items);
            GraphChanged?.Invoke();
        }

        internal void FrameCurrentFlow(string flowId)
        {
            if (graph == null || string.IsNullOrEmpty(flowId)) return;
            var flow = graph.Flows.FirstOrDefault(item => item != null && item.Id == flowId);
            if (flow == null) return;
            var ids = new HashSet<string>(new FrameAnimationGraphTopology(graph)
                .GetReachable(flow.EntryNodeId).Nodes.Select(node => node.InternalId));
            ClearSelection();
            foreach (var pair in nodeViews.Where(pair => ids.Contains(pair.Key))) AddToSelection(pair.Value);
            FrameSelection();
        }

        internal void ApplyCalculatedPositions(IReadOnlyDictionary<AnimationNode, Vector2> positions)
        {
            foreach (var pair in positions)
            {
                if (nodeViews.TryGetValue(pair.Key.InternalId, out var view))
                {
                    var rect = view.GetPosition();
                    rect.position = pair.Value;
                    view.SetPosition(rect);
                }
            }
        }

        private void OpenClipSearch(Vector2 panelPosition)
        {
            var provider = ScriptableObject.CreateInstance<FrameAnimationClipSearchProvider>();
            provider.Configure(graph, clip => CreateNode(clip, contextPosition));
            SearchWindow.Open(new SearchWindowContext(GUIUtility.GUIToScreenPoint(panelPosition)), provider);
        }

        internal void CreateNode(FrameClip clip, Vector2 position)
        {
            if (FrameAnimationGraphMutationService.CreateNode(graph, clip, position, out var node, out var error))
            {
                NodeCreated?.Invoke(node);
                GraphChanged?.Invoke();
                SelectionRequested?.Invoke(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Node, node));
            }
            else
            {
                NotificationRequested?.Invoke(error);
            }
        }

        private GraphViewChange OnGraphViewChanged(GraphViewChange change)
        {
            if (rebuilding || graph == null)
            {
                return change;
            }
            if (change.edgesToCreate != null)
            {
                foreach (var visual in change.edgesToCreate.ToArray())
                {
                    var error = string.Empty;
                    AnimationEdge data = null;
                    var from = visual.output?.node as FrameAnimationClipNodeView;
                    var to = visual.input?.node as FrameAnimationClipNodeView;
                    if (from == null || to == null ||
                        !FrameAnimationGraphMutationService.TryConnect(
                            graph, from.Data, to.Data, out data, out error))
                    {
                        change.edgesToCreate.Remove(visual);
                        NotificationRequested?.Invoke(string.IsNullOrEmpty(error) ? "无法创建连接。" : error);
                        continue;
                    }
                    visual.userData = data;
                }
                GraphChanged?.Invoke();
            }
            if (change.elementsToRemove != null)
            {
                ProcessRemovals(change);
            }
            if (change.movedElements != null)
            {
                var positions = change.movedElements.OfType<FrameAnimationClipNodeView>()
                    .ToDictionary(view => view.Data, view => view.GetPosition().position);
                if (positions.Count > 0)
                {
                    FrameAnimationGraphMutationService.SetNodePositions(graph, positions,
                        "Move Frame Animation Nodes");
                    GraphChanged?.Invoke();
                }
            }
            return change;
        }

        private void ProcessRemovals(GraphViewChange change)
        {
            var nodeViewsToRemove = change.elementsToRemove.OfType<FrameAnimationClipNodeView>().ToArray();
            var removedNodeIds = new HashSet<string>(nodeViewsToRemove.Select(view => view.Data.InternalId));
            if (nodeViewsToRemove.Length > 0)
            {
                var nodes = nodeViewsToRemove.Select(view => view.Data).ToArray();
                var explicitlySelectedEdges = change.elementsToRemove.OfType<Edge>()
                    .Select(edge => edge.userData as AnimationEdge)
                    .Where(edge => edge != null).Distinct().ToArray();
                var entryFlows = graph.Flows.Where(flow => flow != null && removedNodeIds.Contains(flow.EntryNodeId)).ToArray();
                var impact = FrameAnimationGraphImpactAnalyzer.AnalyzeRemoval(
                    graph, nodes, explicitlySelectedEdges);
                var message = BuildRemovalMessage("Node", nodes.Length, impact, entryFlows);
                if (explicitlySelectedEdges.Length > 0)
                {
                    message += $"\n\n同时删除选中的 Edge：{explicitlySelectedEdges.Length}";
                }
                var confirmed = EditorUtility.DisplayDialog("Delete Frame Animation Nodes", message,
                    entryFlows.Length > 0 ? "Delete Nodes + Flows" : "Delete", "Cancel");
                var removed = false;
                var error = string.Empty;
                if (confirmed)
                {
                    removed = FrameAnimationGraphMutationService.RemoveNodesAndEdges(
                        graph, nodes, explicitlySelectedEdges, entryFlows.Length > 0, out error);
                }
                if (!removed)
                {
                    change.elementsToRemove.Clear();
                    if (!string.IsNullOrEmpty(error)) NotificationRequested?.Invoke(error);
                }
                GraphChanged?.Invoke();
                return;
            }

            var remainingEdges = change.elementsToRemove.OfType<Edge>()
                .Where(edge => !IsIncidentTo(edge, removedNodeIds))
                .Select(edge => edge.userData as AnimationEdge).Where(edge => edge != null).Distinct().ToArray();
            if (remainingEdges.Length > 0)
            {
                var impact = FrameAnimationGraphImpactAnalyzer.AnalyzeEdgeRemoval(graph, remainingEdges);
                if (impact.Flows.Count > 0 && !EditorUtility.DisplayDialog("Disconnect Frame Animation Nodes",
                        BuildRemovalMessage("Edge", remainingEdges.Length, impact, Array.Empty<AnimationFlow>()),
                        "Disconnect", "Cancel"))
                {
                    foreach (var edgeView in change.elementsToRemove.OfType<Edge>()
                                 .Where(view => remainingEdges.Contains(view.userData as AnimationEdge)).ToArray())
                    {
                        change.elementsToRemove.Remove(edgeView);
                    }
                }
                else
                {
                    FrameAnimationGraphMutationService.RemoveEdges(graph, remainingEdges);
                }
            }
            GraphChanged?.Invoke();
        }

        private static bool IsIncidentTo(Edge edge, IReadOnlyCollection<string> nodeIds)
        {
            var from = edge?.output?.node as FrameAnimationClipNodeView;
            var to = edge?.input?.node as FrameAnimationClipNodeView;
            return from != null && nodeIds.Contains(from.Data.InternalId) ||
                   to != null && nodeIds.Contains(to.Data.InternalId);
        }

        private static string BuildRemovalMessage(
            string kind,
            int count,
            FrameAnimationGraphImpact impact,
            IReadOnlyCollection<AnimationFlow> entryFlows)
        {
            var message = $"将删除 {count} 个 {kind}。";
            if (impact.Flows.Count > 0)
            {
                message += $"\n\n受影响 Flow：{string.Join(", ", impact.Flows.Select(flow => flow.Id))}" +
                           $"\n将失去可达关系的 Node：{impact.LostNodeCount}";
            }
            if (entryFlows.Count > 0)
            {
                message += $"\n\n入口 Flow 将同时删除：{string.Join(", ", entryFlows.Select(flow => flow.Id))}";
            }
            return message;
        }

        private void OnNodeSelected(FrameAnimationClipNodeView view)
        {
            if (rebuilding)
            {
                return;
            }
            SelectionRequested?.Invoke(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Node, view.Data));
            NotifySelectionSummary();
        }

        private void OnEdgeSelected(FrameAnimationEdgeView view)
        {
            if (rebuilding)
            {
                return;
            }
            SelectionRequested?.Invoke(new FrameAnimationEditorSelection(FrameAnimationEditorSelectionKind.Edge, view.Data));
            NotifySelectionSummary();
        }

        private void NotifySelectionSummary()
        {
            if (rebuilding)
            {
                return;
            }
            MultiSelectionChanged?.Invoke(SelectedNodes);
            var selected = selection.Select(item => item switch
                {
                    FrameAnimationClipNodeView nodeView => new FrameAnimationEditorSelection(
                        FrameAnimationEditorSelectionKind.Node, nodeView.Data),
                    FrameAnimationEdgeView edgeView => new FrameAnimationEditorSelection(
                        FrameAnimationEditorSelectionKind.Edge, edgeView.Data),
                    _ => default
                })
                .Where(item => item.Kind != FrameAnimationEditorSelectionKind.None)
                .ToArray();
            SelectionSetChanged?.Invoke(selected);
        }

        private void OnKeyDown(KeyDownEvent evt)
        {
            if (!TryHandleFocusExitShortcut(evt.keyCode, evt.target is TextField))
            {
                return;
            }
            evt.StopImmediatePropagation();
        }

        internal bool TryHandleFocusExitShortcut(KeyCode keyCode, bool textInputActive)
        {
            if (keyCode != KeyCode.Escape || textInputActive || string.IsNullOrEmpty(focusedFlowId))
            {
                return false;
            }
            ExitFocusRequested?.Invoke();
            return true;
        }

        private void OnDragUpdated(DragUpdatedEvent evt)
        {
            if (DragAndDrop.GetGenericData(ClipDragKey) is FrameClip clip && graph?.Clips.Contains(clip) == true)
            {
                DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
                evt.StopPropagation();
            }
        }

        private void OnDragPerform(DragPerformEvent evt)
        {
            if (!(DragAndDrop.GetGenericData(ClipDragKey) is FrameClip clip) || graph?.Clips.Contains(clip) != true)
            {
                return;
            }
            DragAndDrop.AcceptDrag();
            CreateNode(clip, contentViewContainer.WorldToLocal(evt.mousePosition));
            DragAndDrop.SetGenericData(ClipDragKey, null);
            evt.StopPropagation();
        }
    }
}