using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Globalization;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Autodesk.Navisworks.Api;
using NavisworksTransport.Commands;
using NavisworksTransport.Core.Animation;
using NavisworksTransport.Core.Config;
using NavisworksTransport.PathPlanning;
using NavisworksTransport.UI.WPF.ViewModels;
using NavisworksTransport.Utils;
using Newtonsoft.Json;

namespace NavisworksTransport.Core.Services
{
        /// <summary>
        /// 本地测试自动化 HTTP 控制面。
        /// 当前暴露最小只读/导出接口，后续可在保持协议稳定的前提下追加命令端点。
        /// </summary>
    public sealed class TestAutomationHttpService : IDisposable
    {
        private const int DefaultPort = 18777;
        private const string DefaultHost = "127.0.0.1";
        private const string DefaultAutoTestRoutePrefix = "自动测试_";

        private static readonly Lazy<TestAutomationHttpService> _instance =
            new Lazy<TestAutomationHttpService>(() => new TestAutomationHttpService());

        private readonly object _syncRoot = new object();
        private static int _autoConfirmCollisionAnalysisDialogRequestCount;
        private static int _autoChooseCreateNewDetectionRecordRequestCount;

        private TcpListener _listener;
        private CancellationTokenSource _cts;
        private Task _acceptLoopTask;
        private DateTime _startedAtUtc;
        private string _lastStartError;

        private TestAutomationHttpService()
        {
        }

        public static TestAutomationHttpService Instance => _instance.Value;

        public bool IsRunning
        {
            get
            {
                lock (_syncRoot)
                {
                    return _listener != null;
                }
            }
        }

        public int Port => DefaultPort;

        public string BaseUrl => $"http://{DefaultHost}:{DefaultPort}";

        public static bool ShouldAutoConfirmCollisionAnalysisDialogs =>
            Interlocked.CompareExchange(ref _autoConfirmCollisionAnalysisDialogRequestCount, 0, 0) > 0;

        public static bool ShouldAutoChooseCreateNewDetectionRecord =>
            Interlocked.CompareExchange(ref _autoChooseCreateNewDetectionRecordRequestCount, 0, 0) > 0;

        public void Start()
        {
            lock (_syncRoot)
            {
                if (_listener != null)
                {
                    return;
                }

                try
                {
                    _cts = new CancellationTokenSource();
                    _listener = new TcpListener(IPAddress.Loopback, DefaultPort);
                    _listener.Start();
                    _startedAtUtc = DateTime.UtcNow;
                    _lastStartError = null;
                    _acceptLoopTask = Task.Run(() => AcceptLoopAsync(_cts.Token));

                    LogManager.Info($"[测试HTTP] 服务已启动: {BaseUrl}");
                }
                catch (Exception ex)
                {
                    _lastStartError = ex.Message;
                    _listener = null;
                    _cts?.Dispose();
                    _cts = null;
                    _acceptLoopTask = null;
                    LogManager.Error($"[测试HTTP] 服务启动失败: {ex.Message}", ex);
                }
            }
        }

        public void Stop()
        {
            Task acceptLoopTask = null;

            lock (_syncRoot)
            {
                if (_listener == null)
                {
                    return;
                }

                try
                {
                    _cts?.Cancel();
                    _listener.Stop();
                    acceptLoopTask = _acceptLoopTask;
                }
                catch (Exception ex)
                {
                    LogManager.Warning($"[测试HTTP] 服务停止时出现警告: {ex.Message}");
                }
                finally
                {
                    _listener = null;
                    _acceptLoopTask = null;
                    _cts?.Dispose();
                    _cts = null;
                }
            }

            try
            {
                acceptLoopTask?.Wait(1000);
            }
            catch
            {
                // 忽略退出等待异常
            }

            LogManager.Info("[测试HTTP] 服务已停止");
        }

        private async Task AcceptLoopAsync(CancellationToken cancellationToken)
        {
            while (!cancellationToken.IsCancellationRequested)
            {
                TcpClient client = null;
                try
                {
                    client = await _listener.AcceptTcpClientAsync().ConfigureAwait(false);
                    _ = Task.Run(() => HandleClientAsync(client, cancellationToken), cancellationToken);
                }
                catch (ObjectDisposedException)
                {
                    break;
                }
                catch (SocketException) when (cancellationToken.IsCancellationRequested)
                {
                    break;
                }
                catch (Exception ex)
                {
                    LogManager.Error($"[测试HTTP] 接收请求失败: {ex.Message}", ex);
                    client?.Dispose();
                }
            }
        }

        private async Task HandleClientAsync(TcpClient client, CancellationToken cancellationToken)
        {
            using (client)
            using (var stream = client.GetStream())
            using (var reader = new StreamReader(stream, Encoding.UTF8, false, 4096, true))
            using (var writer = new StreamWriter(stream, new UTF8Encoding(false), 4096, true) { NewLine = "\r\n", AutoFlush = true })
            {
                try
                {
                    string requestLine = await reader.ReadLineAsync().ConfigureAwait(false);
                    if (string.IsNullOrWhiteSpace(requestLine))
                    {
                        return;
                    }

                    string[] requestLineParts = requestLine.Split(' ');
                    if (requestLineParts.Length < 2)
                    {
                        await WriteJsonResponseAsync(writer, 400, BuildEnvelope(false, error: "Invalid request line")).ConfigureAwait(false);
                        return;
                    }

                    string method = requestLineParts[0].Trim().ToUpperInvariant();
                    string requestTarget = requestLineParts[1].Trim();
                    var request = ParseRequestTarget(requestTarget);

                    string headerLine;
                    while (!string.IsNullOrEmpty(headerLine = await reader.ReadLineAsync().ConfigureAwait(false)))
                    {
                        if (cancellationToken.IsCancellationRequested)
                        {
                            return;
                        }
                    }

                    if (string.Equals(method, "GET", StringComparison.OrdinalIgnoreCase) &&
                        string.Equals(request.Path, "/api/test/ping", StringComparison.OrdinalIgnoreCase))
                    {
                        var payload = new
                        {
                            ok = true,
                            service = "NavisworksTransport.TestAutomation",
                            protocol = "http",
                            version = 1,
                            baseUrl = BaseUrl,
                            serverTimeUtc = DateTime.UtcNow.ToString("o")
                        };
                        await WriteJsonResponseAsync(writer, 200, payload).ConfigureAwait(false);
                        return;
                    }

                    if (string.Equals(method, "GET", StringComparison.OrdinalIgnoreCase) &&
                        string.Equals(request.Path, "/api/test/status", StringComparison.OrdinalIgnoreCase))
                    {
                        object payload = InvokeOnUiThread(BuildStatusPayload);
                        await WriteJsonResponseAsync(writer, 200, BuildEnvelope(true, payload)).ConfigureAwait(false);
                        return;
                    }

                    if (string.Equals(method, "GET", StringComparison.OrdinalIgnoreCase) &&
                        string.Equals(request.Path, "/api/test/routes", StringComparison.OrdinalIgnoreCase))
                    {
                        object payload = InvokeOnUiThread(BuildRoutesPayload);
                        await WriteJsonResponseAsync(writer, 200, BuildEnvelope(true, payload)).ConfigureAwait(false);
                        return;
                    }

                    if (string.Equals(method, "GET", StringComparison.OrdinalIgnoreCase) &&
                        string.Equals(request.Path, "/api/test/selection", StringComparison.OrdinalIgnoreCase))
                    {
                        object payload = InvokeOnUiThread(BuildSelectionPayload);
                        await WriteJsonResponseAsync(writer, 200, BuildEnvelope(true, payload)).ConfigureAwait(false);
                        return;
                    }

                    if (string.Equals(method, "POST", StringComparison.OrdinalIgnoreCase) &&
                        string.Equals(request.Path, "/api/test/export-debug-snapshot", StringComparison.OrdinalIgnoreCase))
                    {
                        object snapshotPayload = InvokeOnUiThread(BuildDebugSnapshotPayload);
                        string snapshotFilePath = WriteSnapshotToDisk(snapshotPayload);
                        var payload = new
                        {
                            snapshotFilePath,
                            snapshot = snapshotPayload
                        };

                        await WriteJsonResponseAsync(writer, 200, BuildEnvelope(true, payload)).ConfigureAwait(false);
                        return;
                    }

                    if (string.Equals(method, "POST", StringComparison.OrdinalIgnoreCase) &&
                        string.Equals(request.Path, "/api/test/select-route", StringComparison.OrdinalIgnoreCase))
                    {
                        object payload = InvokeOnUiThread(() => SelectRoutePayload(request.Query));
                        await WriteJsonResponseAsync(writer, 200, BuildEnvelope(true, payload)).ConfigureAwait(false);
                        return;
                    }

                    if (string.Equals(method, "POST", StringComparison.OrdinalIgnoreCase) &&
                        string.Equals(request.Path, "/api/test/select-default-route", StringComparison.OrdinalIgnoreCase))
                    {
                        object payload = InvokeOnUiThread(() => SelectDefaultRoutePayload(request.Query));
                        await WriteJsonResponseAsync(writer, 200, BuildEnvelope(true, payload)).ConfigureAwait(false);
                        return;
                    }

                    if (string.Equals(method, "POST", StringComparison.OrdinalIgnoreCase) &&
                        string.Equals(request.Path, "/api/test/select-animated-object", StringComparison.OrdinalIgnoreCase))
                    {
                        object payload = InvokeOnUiThread(() => SelectAnimatedObjectPayload(request.Query));
                        await WriteJsonResponseAsync(writer, 200, BuildEnvelope(true, payload)).ConfigureAwait(false);
                        return;
                    }

                    if (string.Equals(method, "POST", StringComparison.OrdinalIgnoreCase) &&
                        string.Equals(request.Path, "/api/test/run-ground-collision-test", StringComparison.OrdinalIgnoreCase))
                    {
                        object payload = await RunVirtualCollisionTestAsync(request.Query, PathType.Ground).ConfigureAwait(false);
                        await WriteJsonResponseAsync(writer, 200, BuildEnvelope(true, payload)).ConfigureAwait(false);
                        return;
                    }

                    if (string.Equals(method, "POST", StringComparison.OrdinalIgnoreCase) &&
                        string.Equals(request.Path, "/api/test/run-virtual-collision-test", StringComparison.OrdinalIgnoreCase))
                    {
                        object payload = await RunVirtualCollisionTestAsync(request.Query, null).ConfigureAwait(false);
                        await WriteJsonResponseAsync(writer, 200, BuildEnvelope(true, payload)).ConfigureAwait(false);
                        return;
                    }

                    if (string.Equals(method, "POST", StringComparison.OrdinalIgnoreCase) &&
                        string.Equals(request.Path, "/api/test/analyze-auto-path-grid", StringComparison.OrdinalIgnoreCase))
                    {
                        object payload = InvokeOnUiThread(() => AnalyzeAutoPathGridPayload(request.Query));
                        await WriteJsonResponseAsync(writer, 200, BuildEnvelope(true, payload)).ConfigureAwait(false);
                        return;
                    }

                    if (string.Equals(method, "POST", StringComparison.OrdinalIgnoreCase) &&
                        string.Equals(request.Path, "/api/test/run-auto-path", StringComparison.OrdinalIgnoreCase))
                    {
                        object payload = InvokeOnUiThread(() => RunAutoPathPayload(request.Query));
                        await WriteJsonResponseAsync(writer, 200, BuildEnvelope(true, payload)).ConfigureAwait(false);
                        return;
                    }

                    if (!string.Equals(method, "GET", StringComparison.OrdinalIgnoreCase) &&
                        !string.Equals(method, "POST", StringComparison.OrdinalIgnoreCase))
                    {
                        await WriteJsonResponseAsync(writer, 405, BuildEnvelope(false, error: "Only GET and POST are supported in the current test API")).ConfigureAwait(false);
                        return;
                    }

                    await WriteJsonResponseAsync(writer, 404, BuildEnvelope(false, error: $"Unknown endpoint: {request.Path}")).ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    LogManager.Error($"[测试HTTP] 处理请求失败: {ex.Message}", ex);
                    await WriteJsonResponseAsync(writer, 500, BuildEnvelope(false, error: ex.Message)).ConfigureAwait(false);
                }
            }
        }

        private object BuildStatusPayload()
        {
            Document activeDocument = Autodesk.Navisworks.Api.Application.ActiveDocument;
            PathPlanningManager pathManager = PathPlanningManager.GetActivePathManager();
            PathAnimationManager animationManager = PathAnimationManager.GetInstance();

            PathRoute currentRoute = pathManager?.CurrentRoute;
            List<PathRoute> allRoutes = pathManager?.GetAllRoutes();

            return new
            {
                service = new
                {
                    name = "NavisworksTransport.TestAutomation",
                    protocol = "http",
                    version = 1,
                    isRunning = IsRunning,
                    baseUrl = BaseUrl,
                    port = Port,
                    startedAtUtc = _startedAtUtc == default(DateTime) ? null : _startedAtUtc.ToString("o"),
                    lastStartError = _lastStartError
                },
                environment = new
                {
                    processId = System.Diagnostics.Process.GetCurrentProcess().Id,
                    machineName = Environment.MachineName,
                    logFilePath = LogManager.LogFilePath
                },
                document = new
                {
                    hasActiveDocument = activeDocument != null,
                    fileName = activeDocument?.FileName,
                    title = string.IsNullOrEmpty(activeDocument?.FileName) ? null : Path.GetFileName(activeDocument.FileName),
                    modelCount = activeDocument?.Models?.Count ?? 0
                },
                pathManager = new
                {
                    isAvailable = pathManager != null,
                    routeCount = allRoutes?.Count ?? 0,
                    currentRouteId = currentRoute?.Id,
                    currentRouteName = currentRoute?.Name,
                    currentRoutePathType = currentRoute?.PathType.ToString(),
                    currentRoutePointCount = currentRoute?.Points?.Count ?? 0
                },
                animation = new
                {
                    isAvailable = animationManager != null,
                    currentState = animationManager?.CurrentState.ToString(),
                    isAnimating = animationManager?.IsAnimating ?? false,
                    currentFrame = animationManager?.CurrentFrame ?? 0,
                    totalFrames = animationManager?.TotalFrames ?? 0,
                    hasTrackedRotation = animationManager?.HasTrackedRotation ?? false,
                    currentYawDegrees = animationManager == null ? 0.0 : animationManager.CurrentYaw * 180.0 / Math.PI
                }
            };
        }

        private object BuildDebugSnapshotPayload()
        {
            Document activeDocument = Autodesk.Navisworks.Api.Application.ActiveDocument;
            PathPlanningManager pathManager = PathPlanningManager.GetActivePathManager();
            PathAnimationManager animationManager = PathAnimationManager.GetInstance();

            PathRoute currentRoute = pathManager?.CurrentRoute;
            ModelItem controlledObject = ResolveControlledObject(animationManager);
            var trackedState = ResolveTrackedState(animationManager, controlledObject);
            var geometryState = ResolveGeometryState(controlledObject);
            var boundingBoxState = ResolveBoundingBoxState(controlledObject);

            return new
            {
                snapshotVersion = 1,
                capturedAtUtc = DateTime.UtcNow.ToString("o"),
                document = new
                {
                    hasActiveDocument = activeDocument != null,
                    fileName = activeDocument?.FileName,
                    title = string.IsNullOrEmpty(activeDocument?.FileName) ? null : Path.GetFileName(activeDocument.FileName),
                    modelCount = activeDocument?.Models?.Count ?? 0
                },
                route = new
                {
                    isAvailable = currentRoute != null,
                    id = currentRoute?.Id,
                    name = currentRoute?.Name,
                    pathType = currentRoute?.PathType.ToString(),
                    pointCount = currentRoute?.Points?.Count ?? 0
                },
                animation = new
                {
                    isAvailable = animationManager != null,
                    currentState = animationManager?.CurrentState.ToString(),
                    isAnimating = animationManager?.IsAnimating ?? false,
                    currentFrame = animationManager?.CurrentFrame ?? 0,
                    totalFrames = animationManager?.TotalFrames ?? 0,
                    currentYawDegrees = animationManager == null ? 0.0 : animationManager.CurrentYaw * 180.0 / Math.PI,
                    hasTrackedRotation = animationManager?.HasTrackedRotation ?? false
                },
                controlledObject = new
                {
                    exists = controlledObject != null,
                    displayName = controlledObject?.DisplayName,
                    instanceGuid = controlledObject == null ? null : controlledObject.InstanceGuid.ToString(),
                    isVirtualObject = controlledObject != null &&
                                      VirtualObjectManager.Instance.IsVirtualObjectActive &&
                                      ReferenceEquals(VirtualObjectManager.Instance.CurrentVirtualObject, controlledObject),
                    trackedState,
                    geometryState,
                    boundingBox = boundingBoxState
                },
                environment = new
                {
                    processId = System.Diagnostics.Process.GetCurrentProcess().Id,
                    machineName = Environment.MachineName,
                    logFilePath = LogManager.LogFilePath
                }
            };
        }

        private object BuildRoutesPayload()
        {
            PathPlanningManager pathManager = PathPlanningManager.GetActivePathManager();
            List<PathRoute> routes = pathManager?.GetAllRoutes() ?? new List<PathRoute>();
            PathRoute currentRoute = pathManager?.CurrentRoute;

            return new
            {
                isAvailable = pathManager != null,
                currentRouteId = currentRoute?.Id,
                currentRouteName = currentRoute?.Name,
                currentRoutePathType = currentRoute?.PathType.ToString(),
                totalRouteCount = routes.Count,
                routes = routes.Select(route => SerializeRoute(route, currentRoute)).ToList(),
                suggestedAutoTestRoutes = new
                {
                    ground = TryFindAutoTestRoute(routes, PathType.Ground)?.Name,
                    hoisting = TryFindAutoTestRoute(routes, PathType.Hoisting)?.Name,
                    rail = TryFindAutoTestRoute(routes, PathType.Rail)?.Name
                }
            };
        }

        private object BuildSelectionPayload()
        {
            Document activeDocument = Autodesk.Navisworks.Api.Application.ActiveDocument;
            var selectedItems = activeDocument?.CurrentSelection?.SelectedItems?.Cast<ModelItem>().Where(item => item != null).ToList()
                               ?? new List<ModelItem>();

            return new
            {
                hasActiveDocument = activeDocument != null,
                selectionCount = selectedItems.Count,
                selectedItems = selectedItems.Select(SerializeModelItem).ToList()
            };
        }

        private object SelectRoutePayload(Dictionary<string, string> query)
        {
            PathPlanningManager pathManager = RequirePathManager();
            string routeName = GetRequiredQueryValue(query, "name");
            List<PathRoute> routes = pathManager.GetAllRoutes() ?? new List<PathRoute>();

            PathRoute selectedRoute = routes.FirstOrDefault(route =>
                string.Equals(route.Name, routeName, StringComparison.OrdinalIgnoreCase));
            if (selectedRoute == null)
            {
                throw new InvalidOperationException($"找不到指定路径: {routeName}");
            }

            pathManager.SetCurrentRoute(selectedRoute);
            LogManager.Info($"[测试HTTP] 已切换当前路径: {selectedRoute.Name} ({selectedRoute.PathType})");

            return new
            {
                selected = SerializeRoute(selectedRoute, selectedRoute),
                totalRouteCount = routes.Count
            };
        }

        private object SelectDefaultRoutePayload(Dictionary<string, string> query)
        {
            PathPlanningManager pathManager = RequirePathManager();
            string pathTypeValue = GetRequiredQueryValue(query, "pathType");
            string prefix = GetOptionalQueryValue(query, "prefix") ?? DefaultAutoTestRoutePrefix;

            if (!Enum.TryParse(pathTypeValue, true, out PathType pathType))
            {
                throw new InvalidOperationException($"无法解析路径类型: {pathTypeValue}");
            }

            List<PathRoute> routes = pathManager.GetAllRoutes() ?? new List<PathRoute>();
            PathRoute selectedRoute = routes
                .FirstOrDefault(route =>
                    route.PathType == pathType &&
                    !string.IsNullOrWhiteSpace(route.Name) &&
                    route.Name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase));

            if (selectedRoute == null)
            {
                throw new InvalidOperationException(
                    $"找不到默认测试路径: prefix={prefix}, pathType={pathType}");
            }

            pathManager.SetCurrentRoute(selectedRoute);
            LogManager.Info($"[测试HTTP] 已切换默认测试路径: {selectedRoute.Name} ({selectedRoute.PathType})");

            return new
            {
                selectionRule = new
                {
                    prefix,
                    pathType = pathType.ToString()
                },
                selected = SerializeRoute(selectedRoute, selectedRoute)
            };
        }

        private object SelectAnimatedObjectPayload(Dictionary<string, string> query)
        {
            AnimationControlViewModel animationViewModel = RequireAnimationControlViewModel();
            PathPlanningManager pathManager = RequirePathManager();
            animationViewModel.SetPathPlanningManager(pathManager);

            ModelItem animatedObject = ResolveAnimatedObjectFromQuery(query);
            SelectDocumentItem(animatedObject);

            if (!animationViewModel.SelectAnimatedObjectCommand.CanExecute(null))
            {
                throw new InvalidOperationException("当前动画视图模型不允许执行“选择移动物体”命令");
            }

            animationViewModel.UseVirtualObject = false;
            animationViewModel.SelectAnimatedObjectCommand.Execute(null);

            if (!ReferenceEquals(animationViewModel.SelectedAnimatedObject, animatedObject))
            {
                throw new InvalidOperationException("选择真实物体失败：动画视图模型未保留选中的对象");
            }

            return new
            {
                selectedAnimatedObject = SerializeModelItem(animatedObject),
                canGenerateAnimation = animationViewModel.CanGenerateAnimation,
                isManualCollisionTargetEnabled = animationViewModel.IsManualCollisionTargetEnabled
            };
        }

        private async Task<object> RunVirtualCollisionTestAsync(Dictionary<string, string> query, PathType? fixedPathType)
        {
            using (EnableAutoConfirmCollisionAnalysisDialogs())
            using (EnableAutoChooseCreateNewDetectionRecord())
            {
                int timeoutSeconds = ParseTimeoutSeconds(query, 180);
                DateTime deadlineUtc = DateTime.UtcNow.AddSeconds(timeoutSeconds);

                var setupResult = InvokeOnUiThread(() => PrepareVirtualCollisionTest(query, fixedPathType));

                await WaitForConditionAsync(
                    deadlineUtc,
                    () => InvokeOnUiThread(() =>
                    {
                        var animationManager = PathAnimationManager.GetInstance();
                        return animationManager != null &&
                               animationManager.TotalFrames > 0 &&
                               (animationManager.CurrentState == AnimationState.Ready ||
                                animationManager.CurrentState == AnimationState.Finished);
                    }),
                    "等待动画生成完成超时").ConfigureAwait(false);

                InvokeOnUiThread(() =>
                {
                    StartPreparedAnimation();
                    return true;
                });

                await WaitForConditionAsync(
                    deadlineUtc,
                    () => InvokeOnUiThread(() => PathAnimationManager.GetInstance()?.CurrentState == AnimationState.Finished),
                    "等待动画播放和碰撞检测完成超时").ConfigureAwait(false);

                await WaitForConditionAsync(
                    deadlineUtc,
                    () => InvokeOnUiThread(() =>
                    {
                        var animationVm = RequireAnimationControlViewModel();
                        return animationVm.HasGeneratedCollisionReport;
                    }),
                    "等待碰撞报告生成超时").ConfigureAwait(false);

                return InvokeOnUiThread(() =>
                {
                    AnimationControlViewModel animationVm = RequireAnimationControlViewModel();
                    PathAnimationManager animationManager = PathAnimationManager.GetInstance();
                    CollisionReportResult report = animationVm.LastGeneratedReport;

                    return new
                    {
                        route = setupResult.route,
                        animatedObject = setupResult.animatedObject,
                        requestedPathType = setupResult.pathType.ToString(),
                        timeoutSeconds,
                        automation = new
                        {
                            autoConfirmedCollisionAnalysisDialog = true,
                            autoChooseCreateNewDetectionRecord = true
                        },
                        animation = new
                        {
                            currentState = animationManager?.CurrentState.ToString(),
                            totalFrames = animationManager?.TotalFrames ?? 0,
                            currentFrame = animationManager?.CurrentFrame ?? 0,
                            detectionRecordId = animationManager?.CurrentDetectionRecordId
                        },
                        report = report == null
                            ? null
                            : new
                            {
                                totalCollisions = report.TotalCollisions,
                                uniqueCollidedObjectsCount = report.UniqueCollidedObjectsCount,
                                pathName = report.PathName,
                                movingObjectInfo = report.MovingObjectInfo,
                                hasScreenshots = report.Screenshots != null && report.Screenshots.Count > 0,
                                screenshotCount = report.Screenshots?.Count ?? 0,
                                resultId = report.ResultId,
                                routeId = report.RouteId
                            }
                    };
                });
            }
        }

        private static object BuildEnvelope(bool ok, object data = null, string error = null)
        {
            return new Dictionary<string, object>
            {
                ["ok"] = ok,
                ["data"] = data,
                ["error"] = error
            };
        }

        private static T InvokeOnUiThread<T>(Func<T> func)
        {
            var dispatcher = System.Windows.Application.Current?.Dispatcher;
            if (dispatcher == null || dispatcher.CheckAccess())
            {
                return func();
            }

            return dispatcher.Invoke(func);
        }

        private static ModelItem ResolveControlledObject(PathAnimationManager animationManager)
        {
            if (VirtualObjectManager.Instance.IsVirtualObjectActive &&
                VirtualObjectManager.Instance.CurrentVirtualObject != null)
            {
                return VirtualObjectManager.Instance.CurrentVirtualObject;
            }

            return animationManager?.AnimatedObject;
        }

        private static object SerializeModelItem(ModelItem item)
        {
            if (item == null)
            {
                return null;
            }

            return new
            {
                displayName = item.DisplayName,
                instanceGuid = item.InstanceGuid.ToString()
            };
        }

        private static object SerializeRoute(PathRoute route, PathRoute currentRoute)
        {
            return new
            {
                id = route?.Id,
                name = route?.Name,
                pathType = route?.PathType.ToString(),
                pointCount = route?.Points?.Count ?? 0,
                isCurrent = currentRoute != null && ReferenceEquals(route, currentRoute),
                matchesAutoTestPrefix = !string.IsNullOrWhiteSpace(route?.Name) &&
                                        route.Name.StartsWith(DefaultAutoTestRoutePrefix, StringComparison.OrdinalIgnoreCase)
            };
        }

        private static PathRoute TryFindAutoTestRoute(IEnumerable<PathRoute> routes, PathType pathType)
        {
            return routes?.FirstOrDefault(route =>
                route != null &&
                route.PathType == pathType &&
                !string.IsNullOrWhiteSpace(route.Name) &&
                route.Name.StartsWith(DefaultAutoTestRoutePrefix, StringComparison.OrdinalIgnoreCase));
        }

        private static object AnalyzeAutoPathGridPayload(Dictionary<string, string> query)
        {
            PathPlanningManager pathManager = RequirePathManager();
            PathRoute route = ResolveVirtualCollisionRoute(pathManager, query, null);
            if (route.Points == null || route.Points.Count < 2)
            {
                throw new InvalidOperationException($"路径点不足，无法分析自动路径网格: {route.Name}");
            }

            List<PathPoint> orderedPoints = route.Points.OrderBy(point => point.Index).ToList();
            PathPoint startPoint = orderedPoints.First();
            PathPoint endPoint = orderedPoints.Last();

            BoundingBox3D bounds = InvokePathManagerPrivate<BoundingBox3D>(pathManager, "GetModelBounds");
            double gridSize = InvokePathManagerPrivate<double>(pathManager, "CalculateOptimalGridSize", bounds);

            var config = ConfigManager.Instance.Current?.PathEditing
                         ?? throw new InvalidOperationException("缺少 PathEditing 配置，无法分析自动路径网格");

            double objectLengthInMeters = config.ObjectLengthMeters;
            double objectWidthInMeters = config.ObjectWidthMeters;
            double objectHeightInMeters = config.ObjectHeightMeters;
            double safetyMarginInMeters = config.SafetyMarginMeters;
            double objectRadiusInMeters = Math.Max(objectLengthInMeters, objectWidthInMeters) / 2.0;

            var gridMapGenerator = new GridMapGenerator();
            GridMap gridMap = gridMapGenerator.GenerateFromBIM(
                bounds,
                gridSize,
                objectRadiusInMeters,
                safetyMarginInMeters,
                startPoint.Position,
                endPoint.Position,
                objectHeightInMeters);

            return new
            {
                requestedPathType = route.PathType.ToString(),
                route = new
                {
                    id = route.Id,
                    name = route.Name,
                    pathType = route.PathType.ToString(),
                    pointCount = route.Points.Count,
                    startPoint = SerializePathPoint(startPoint),
                    endPoint = SerializePathPoint(endPoint)
                },
                planningParameters = new
                {
                    gridSizeInMeters = gridSize,
                    objectLengthInMeters,
                    objectWidthInMeters,
                    objectHeightInMeters,
                    objectRadiusInMeters,
                    safetyMarginInMeters
                },
                bounds = new
                {
                    min = SerializePoint3D(bounds.Min),
                    max = SerializePoint3D(bounds.Max)
                },
                gridStats = SerializeGridStats(gridMap),
                obstacleDiagnostics = BuildObstacleDiagnostics(gridMapGenerator, gridMap, objectHeightInMeters, safetyMarginInMeters)
            };
        }

        private static object RunAutoPathPayload(Dictionary<string, string> query)
        {
            PathPlanningManager pathManager = RequirePathManager();
            PathRoute route = ResolveVirtualCollisionRoute(pathManager, query, null);
            if (route.Points == null || route.Points.Count < 2)
            {
                throw new InvalidOperationException($"路径点不足，无法执行自动路径规划: {route.Name}");
            }

            List<PathPoint> orderedPoints = route.Points.OrderBy(point => point.Index).ToList();
            PathPoint startPoint = orderedPoints.First();
            PathPoint endPoint = orderedPoints.Last();

            var config = ConfigManager.Instance.Current?.PathEditing
                         ?? throw new InvalidOperationException("缺少 PathEditing 配置，无法执行自动路径规划");

            BoundingBox3D bounds = InvokePathManagerPrivate<BoundingBox3D>(pathManager, "GetModelBounds");
            double gridSize = InvokePathManagerPrivate<double>(pathManager, "CalculateOptimalGridSize", bounds);
            double objectHeightInMeters = config.ObjectHeightMeters;
            double objectLengthInMeters = config.ObjectLengthMeters;
            double objectWidthInMeters = config.ObjectWidthMeters;
            double safetyMarginInMeters = config.SafetyMarginMeters;
            double objectRadiusInMeters = Math.Max(objectLengthInMeters, objectWidthInMeters) / 2.0;
            PathStrategy strategy = PathStrategy.Shortest;

            string strategyText = GetOptionalQueryValue(query, "strategy");
            if (!string.IsNullOrWhiteSpace(strategyText) &&
                Enum.TryParse(strategyText, true, out PathStrategy parsedStrategy))
            {
                strategy = parsedStrategy;
            }

            PathRoute autoRoute = pathManager
                .AutoPlanPath(
                    startPoint,
                    endPoint,
                    objectRadiusInMeters,
                    safetyMarginInMeters,
                    gridSize,
                    objectHeightInMeters,
                    strategy)
                .GetAwaiter()
                .GetResult();

            if (autoRoute == null)
            {
                throw new InvalidOperationException("AutoPlanPath 返回空结果");
            }

            return new
            {
                sourceRoute = new
                {
                    id = route.Id,
                    name = route.Name,
                    pathType = route.PathType.ToString()
                },
                generatedRoute = new
                {
                    id = autoRoute.Id,
                    name = autoRoute.Name,
                    pathType = autoRoute.PathType.ToString(),
                    pointCount = autoRoute.Points?.Count ?? 0,
                    length = autoRoute.TotalLength
                },
                planningParameters = new
                {
                    gridSizeInMeters = gridSize,
                    objectHeightInMeters,
                    objectLengthInMeters,
                    objectWidthInMeters,
                    objectRadiusInMeters,
                    safetyMarginInMeters,
                    strategy = strategy.ToString()
                }
            };
        }

        private static PathPlanningManager RequirePathManager()
        {
            PathPlanningManager pathManager = PathPlanningManager.GetActivePathManager();
            if (pathManager == null)
            {
                throw new InvalidOperationException("PathPlanningManager 当前不可用");
            }

            return pathManager;
        }

        private static string GetRequiredQueryValue(Dictionary<string, string> query, string key)
        {
            string value = GetOptionalQueryValue(query, key);
            if (string.IsNullOrWhiteSpace(value))
            {
                throw new InvalidOperationException($"缺少必填参数: {key}");
            }

            return value;
        }

        private static string GetOptionalQueryValue(Dictionary<string, string> query, string key)
        {
            if (query == null || string.IsNullOrWhiteSpace(key))
            {
                return null;
            }

            query.TryGetValue(key, out string value);
            return string.IsNullOrWhiteSpace(value) ? null : value;
        }

        private static RequestTarget ParseRequestTarget(string requestTarget)
        {
            string path = requestTarget ?? "/";
            var query = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

            int queryStartIndex = path.IndexOf('?');
            if (queryStartIndex >= 0)
            {
                string queryString = path.Substring(queryStartIndex + 1);
                path = path.Substring(0, queryStartIndex);

                foreach (string pair in queryString.Split(new[] { '&' }, StringSplitOptions.RemoveEmptyEntries))
                {
                    string[] kv = pair.Split(new[] { '=' }, 2);
                    string key = Uri.UnescapeDataString(kv[0] ?? string.Empty);
                    string value = kv.Length > 1 ? Uri.UnescapeDataString(kv[1] ?? string.Empty) : string.Empty;
                    if (!string.IsNullOrWhiteSpace(key))
                    {
                        query[key] = value;
                    }
                }
            }

            return new RequestTarget
            {
                Path = string.IsNullOrWhiteSpace(path) ? "/" : path,
                Query = query
            };
        }

        private sealed class RequestTarget
        {
            public string Path { get; set; }

            public Dictionary<string, string> Query { get; set; }
        }

        private static object ResolveTrackedState(PathAnimationManager animationManager, ModelItem controlledObject)
        {
            if (animationManager == null || controlledObject == null || !animationManager.ControlsAnimatedObject(controlledObject))
            {
                return new
                {
                    isAvailable = false,
                    reason = animationManager == null ? "PathAnimationManagerUnavailable" : "ControlledObjectUnavailable"
                };
            }

            var currentState = animationManager.GetObjectCurrentPosition(controlledObject);
            return new
            {
                isAvailable = true,
                position = SerializePoint3D(currentState.Position),
                yawRadians = currentState.Yaw,
                yawDegrees = currentState.Yaw * 180.0 / Math.PI,
                hasTrackedRotation = animationManager.HasTrackedRotation,
                trackedRotation = animationManager.HasTrackedRotation
                    ? SerializeRotation3D(animationManager.TrackedRotation)
                    : null
            };
        }

        private static object ResolveGeometryState(ModelItem controlledObject)
        {
            if (controlledObject == null)
            {
                return new
                {
                    isAvailable = false,
                    reason = "ControlledObjectUnavailable"
                };
            }

            bool hasGeometryRotation = ModelItemTransformHelper.TryGetCurrentGeometryRotation(controlledObject, out Rotation3D geometryRotation);
            bool hasOverrideRotation = ModelItemTransformHelper.TryGetCurrentOverrideRotation(controlledObject, out Rotation3D overrideRotation);

            return new
            {
                isAvailable = true,
                geometryRotation = hasGeometryRotation ? SerializeRotation3D(geometryRotation) : null,
                overrideRotation = hasOverrideRotation ? SerializeRotation3D(overrideRotation) : null
            };
        }

        private static object ResolveBoundingBoxState(ModelItem controlledObject)
        {
            if (controlledObject == null)
            {
                return new
                {
                    isAvailable = false,
                    reason = "ControlledObjectUnavailable"
                };
            }

            BoundingBox3D boundingBox = controlledObject.BoundingBox();
            return new
            {
                isAvailable = true,
                min = SerializePoint3D(boundingBox.Min),
                max = SerializePoint3D(boundingBox.Max),
                center = SerializePoint3D(boundingBox.Center)
            };
        }

        private static object SerializePoint3D(Point3D point)
        {
            if (point == null)
            {
                return null;
            }

            return new
            {
                x = point.X,
                y = point.Y,
                z = point.Z
            };
        }

        private static object SerializePathPoint(PathPoint point)
        {
            if (point == null)
            {
                return null;
            }

            return new
            {
                id = point.Id,
                name = point.Name,
                type = point.Type.ToString(),
                index = point.Index,
                position = SerializePoint3D(point.Position)
            };
        }

        private static object SerializeGridStats(GridMap gridMap)
        {
            if (gridMap == null)
            {
                return null;
            }

            int walkableCellCount = 0;
            int nonWalkableCellCount = 0;
            int obstacleCellCount = 0;
            int holeCellCount = 0;
            int boundaryLayerCount = 0;

            for (int x = 0; x < gridMap.Width; x++)
            {
                for (int y = 0; y < gridMap.Height; y++)
                {
                    GridCell cell = gridMap.Cells[x, y];
                    bool isWalkable = cell.HasAnyWalkableLayer();
                    if (isWalkable)
                    {
                        walkableCellCount++;
                    }
                    else
                    {
                        nonWalkableCellCount++;
                    }

                    if (string.Equals(cell.CellType, "障碍物", StringComparison.Ordinal))
                    {
                        obstacleCellCount++;
                    }

                    if (string.Equals(cell.CellType, "空洞", StringComparison.Ordinal))
                    {
                        holeCellCount++;
                    }

                    if (cell.HeightLayers != null)
                    {
                        boundaryLayerCount += cell.HeightLayers.Count(layer => layer.IsBoundary);
                    }
                }
            }

            int totalCellCount = gridMap.Width * gridMap.Height;

            return new
            {
                width = gridMap.Width,
                height = gridMap.Height,
                totalCellCount,
                walkableCellCount,
                nonWalkableCellCount,
                obstacleCellCount,
                holeCellCount,
                boundaryLayerCount,
                obstacleRatio = totalCellCount == 0 ? 0.0 : (double)obstacleCellCount / totalCellCount,
                nonWalkableRatio = totalCellCount == 0 ? 0.0 : (double)nonWalkableCellCount / totalCellCount
            };
        }

        private static object BuildObstacleDiagnostics(GridMapGenerator gridMapGenerator, GridMap gridMap, double objectHeightInMeters, double safetyMarginInMeters)
        {
            if (gridMapGenerator == null || gridMap == null)
            {
                return null;
            }

            double metersToModelUnits = UnitsConverter.GetMetersToUnitsConversionFactor(Application.ActiveDocument.Units);
            double scanHeightInModelUnits = (objectHeightInMeters + safetyMarginInMeters) * metersToModelUnits;

            var traversableItems = CategoryAttributeManager.GetAllTraversableLogisticsItems().ToList();
            var irrelevantItems = CategoryAttributeManager.GetLogisticsItemsByType("无关项");

            var collectRelatedItemsMethod = typeof(GridMapGenerator).GetMethod(
                "CollectRelatedItems",
                System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
            var postProcessGeometryItemsMethod = typeof(GridMapGenerator).GetMethod(
                "PostProcessGeometryItems",
                System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
            var getObstacleElevationRangeMethod = typeof(GridMapGenerator).GetMethod(
                "GetObstacleElevationRange",
                System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic,
                null,
                new[] { typeof(Point3D), typeof(Point3D), typeof(GridMap) },
                null);
            var calculateBoundingBoxGridCoverageMethod = typeof(GridMapGenerator).GetMethod(
                "CalculateBoundingBoxGridCoverage",
                System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);

            var traversableRelatedItems = (HashSet<ModelItem>)collectRelatedItemsMethod.Invoke(gridMapGenerator, new object[] { traversableItems });
            var irrelevantRelatedItems = (HashSet<ModelItem>)collectRelatedItemsMethod.Invoke(gridMapGenerator, new object[] { irrelevantItems });
            var geometryItems = ModelItemAnalysisHelper.GetAllVisibleGeometryItems();
            var itemCache = (Dictionary<ModelItem, ItemProperties>)postProcessGeometryItemsMethod.Invoke(
                gridMapGenerator,
                new object[] { geometryItems, traversableRelatedItems, irrelevantRelatedItems });

            var validItems = itemCache
                .Where(kvp => kvp.Value.HasGeometry &&
                              !kvp.Value.IsContainer &&
                              !kvp.Value.IsChannelItem &&
                              !kvp.Value.IsChildOfChannel &&
                              kvp.Value.BoundingBox != null &&
                              kvp.Value.IsInScanHeightRange)
                .ToList();

            double walkableMinElevation = double.MaxValue;
            double walkableMaxElevation = double.MinValue;
            int walkableGridCount = 0;
            for (int x = 0; x < gridMap.Width; x++)
            {
                for (int y = 0; y < gridMap.Height; y++)
                {
                    GridCell cell = gridMap.Cells[x, y];
                    if (!cell.HasAnyWalkableLayer() || cell.HeightLayers == null || cell.HeightLayers.Count == 0)
                    {
                        continue;
                    }

                    walkableGridCount++;
                    double cellElevation = cell.HeightLayers[0].Z;
                    walkableMinElevation = Math.Min(walkableMinElevation, cellElevation);
                    walkableMaxElevation = Math.Max(walkableMaxElevation, cellElevation);
                }
            }

            if (walkableGridCount == 0)
            {
                walkableMinElevation = 0.0;
                walkableMaxElevation = 0.0;
            }

            double scanMin = walkableMinElevation;
            double scanMax = walkableMaxElevation + scanHeightInModelUnits;

            var keptItems = new List<object>();
            var filteredSampleItems = new List<object>();
            int filteredByHeightCount = 0;

            foreach (var kvp in validItems)
            {
                BoundingBox3D bbox = kvp.Value.BoundingBox;
                var elevationRange = ((double min, double max))getObstacleElevationRangeMethod.Invoke(
                    gridMapGenerator,
                    new object[] { bbox.Min, bbox.Max, gridMap });

                bool isInRange = !(elevationRange.max <= scanMin || elevationRange.min > scanMax);
                if (!isInRange)
                {
                    filteredByHeightCount++;
                    if (filteredSampleItems.Count < 10)
                    {
                        filteredSampleItems.Add(new
                        {
                            displayName = kvp.Key.DisplayName,
                            bboxMin = SerializePoint3D(bbox.Min),
                            bboxMax = SerializePoint3D(bbox.Max),
                            minElevation = elevationRange.min,
                            maxElevation = elevationRange.max
                        });
                    }

                    continue;
                }

                if (keptItems.Count < 30)
                {
                    var coveredCells = (List<(int x, int y)>)calculateBoundingBoxGridCoverageMethod.Invoke(
                        gridMapGenerator,
                        new object[] { bbox, gridMap });

                    object triangleBounds = keptItems.Count < 8
                        ? SerializeTriangleBounds(kvp.Key)
                        : null;

                    keptItems.Add(new
                    {
                        displayName = kvp.Key.DisplayName,
                        bboxMin = SerializePoint3D(bbox.Min),
                        bboxMax = SerializePoint3D(bbox.Max),
                        triangleBounds,
                        minElevation = elevationRange.min,
                        maxElevation = elevationRange.max,
                        coveredCellCount = coveredCells.Count
                    });
                }
            }

            return new
            {
                geometryItemCount = geometryItems.Count,
                traversableItemCount = traversableItems.Count,
                traversableRelatedItemCount = traversableRelatedItems.Count,
                irrelevantItemCount = irrelevantItems.Count,
                irrelevantRelatedItemCount = irrelevantRelatedItems.Count,
                postProcessedItemCount = itemCache.Count,
                validItemCount = validItems.Count,
                walkableGridCount,
                walkableMinElevation,
                walkableMaxElevation,
                scanHeightInModelUnits,
                scanMin,
                scanMax,
                filteredByHeightCount,
                keptItemSample = keptItems,
                filteredByHeightSample = filteredSampleItems
            };
        }

        private static object SerializeTriangleBounds(ModelItem item)
        {
            if (item == null)
            {
                return null;
            }

            List<Triangle3D> triangles = GeometryHelper.ExtractTriangles(new[] { item });
            if (triangles == null || triangles.Count == 0)
            {
                return null;
            }

            double minX = triangles.Min(t => Math.Min(t.Point1.X, Math.Min(t.Point2.X, t.Point3.X)));
            double minY = triangles.Min(t => Math.Min(t.Point1.Y, Math.Min(t.Point2.Y, t.Point3.Y)));
            double minZ = triangles.Min(t => Math.Min(t.Point1.Z, Math.Min(t.Point2.Z, t.Point3.Z)));
            double maxX = triangles.Max(t => Math.Max(t.Point1.X, Math.Max(t.Point2.X, t.Point3.X)));
            double maxY = triangles.Max(t => Math.Max(t.Point1.Y, Math.Max(t.Point2.Y, t.Point3.Y)));
            double maxZ = triangles.Max(t => Math.Max(t.Point1.Z, Math.Max(t.Point2.Z, t.Point3.Z)));

            return new
            {
                min = SerializePoint3D(new Point3D(minX, minY, minZ)),
                max = SerializePoint3D(new Point3D(maxX, maxY, maxZ))
            };
        }

        private static T InvokePathManagerPrivate<T>(PathPlanningManager pathManager, string methodName, params object[] args)
        {
            var method = typeof(PathPlanningManager).GetMethod(
                methodName,
                System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);

            if (method == null)
            {
                throw new MissingMethodException(typeof(PathPlanningManager).FullName, methodName);
            }

            object result = method.Invoke(pathManager, args);
            if (result == null)
            {
                return default(T);
            }

            return (T)result;
        }

        private static object SerializeRotation3D(Rotation3D rotation)
        {
            var linear = new Transform3D(rotation).Linear;
            return new
            {
                quaternion = new
                {
                    x = rotation.A,
                    y = rotation.B,
                    z = rotation.C,
                    w = rotation.D
                },
                axes = new
                {
                    hostX = new
                    {
                        x = linear.Get(0, 0),
                        y = linear.Get(1, 0),
                        z = linear.Get(2, 0)
                    },
                    hostY = new
                    {
                        x = linear.Get(0, 1),
                        y = linear.Get(1, 1),
                        z = linear.Get(2, 1)
                    },
                    hostZ = new
                    {
                        x = linear.Get(0, 2),
                        y = linear.Get(1, 2),
                        z = linear.Get(2, 2)
                    }
                }
            };
        }

        private static string WriteSnapshotToDisk(object snapshotPayload)
        {
            string logDirectory = Path.GetDirectoryName(LogManager.LogFilePath);
            string snapshotDirectory = Path.Combine(logDirectory ?? AppDomain.CurrentDomain.BaseDirectory, "test-automation");
            Directory.CreateDirectory(snapshotDirectory);

            string fileName = string.Format(
                CultureInfo.InvariantCulture,
                "debug-snapshot-{0:yyyyMMdd-HHmmss-fff}.json",
                DateTime.Now);
            string fullPath = Path.Combine(snapshotDirectory, fileName);
            string json = JsonConvert.SerializeObject(snapshotPayload, Formatting.Indented);
            File.WriteAllText(fullPath, json, new UTF8Encoding(false));

            LogManager.Info($"[测试HTTP] 已导出调试快照: {fullPath}");
            return fullPath;
        }

        private static AnimationControlViewModel RequireAnimationControlViewModel()
        {
            var animationViewModel = AnimationControlViewModel.Instance;
            if (animationViewModel == null)
            {
                throw new InvalidOperationException("AnimationControlViewModel 当前不可用，请先打开插件动画页签");
            }

            return animationViewModel;
        }

        private static PreparedVirtualCollisionTest PrepareVirtualCollisionTest(Dictionary<string, string> query, PathType? fixedPathType)
        {
            PathPlanningManager pathManager = RequirePathManager();
            AnimationControlViewModel animationViewModel = RequireAnimationControlViewModel();
            animationViewModel.SetPathPlanningManager(pathManager);

            PathRoute route = ResolveVirtualCollisionRoute(pathManager, query, fixedPathType);
            pathManager.SetCurrentRoute(route);
            animationViewModel.SetCurrentPath(CreatePathRouteViewModel(route));

            animationViewModel.IsManualCollisionTargetEnabled = false;
            animationViewModel.UseVirtualObject = true;
            object animatedObjectPayload = new
            {
                mode = "VirtualObject",
                displayName = "虚拟物体"
            };

            if (!animationViewModel.CanGenerateAnimation || !animationViewModel.GenerateAnimationCommand.CanExecute(null))
            {
                throw new InvalidOperationException($"{route.PathType} 虚拟物体碰撞测试准备失败：当前条件下不能生成动画");
            }

            animationViewModel.GenerateAnimationCommand.Execute(null);

            LogManager.Info(
                $"[测试HTTP] 已开始准备虚拟物体碰撞测试: 路径={route.Name}, 类型={route.PathType}");

            return new PreparedVirtualCollisionTest
            {
                pathType = route.PathType,
                route = SerializeRoute(route, route),
                animatedObject = animatedObjectPayload
            };
        }

        private static void StartPreparedAnimation()
        {
            AnimationControlViewModel animationViewModel = RequireAnimationControlViewModel();
            PathAnimationManager animationManager = PathAnimationManager.GetInstance();
            if (animationManager == null)
            {
                throw new InvalidOperationException("PathAnimationManager 当前不可用，无法开始播放");
            }

            if (animationManager.CurrentState == AnimationState.Paused)
            {
                animationManager.ResumeAnimation();
                LogManager.Info("[测试HTTP] 已从暂停状态恢复自动测试动画播放");
                return;
            }

            if (animationManager.IsAnimating)
            {
                LogManager.Info("[测试HTTP] 动画已经在播放中，跳过重复开始");
                return;
            }

            if (animationManager.CurrentState != AnimationState.Ready &&
                animationManager.CurrentState != AnimationState.Finished)
            {
                throw new InvalidOperationException($"动画尚未就绪，当前状态={animationManager.CurrentState}");
            }

            animationManager.ClearExclusionCache();
            ModelHighlightHelper.ClearCollisionHighlights();
            animationManager.StartAnimation();
            LogManager.Info("[测试HTTP] 已启动自动测试动画播放");
        }

        private static PathRoute ResolveVirtualCollisionRoute(PathPlanningManager pathManager, Dictionary<string, string> query, PathType? fixedPathType)
        {
            string routeName = GetOptionalQueryValue(query, "routeName");
            string pathTypeText = fixedPathType.HasValue
                ? fixedPathType.Value.ToString()
                : GetOptionalQueryValue(query, "pathType");
            List<PathRoute> routes = pathManager.GetAllRoutes() ?? new List<PathRoute>();
            PathType pathType = fixedPathType ?? ParsePathTypeOrThrow(pathTypeText, "pathType");

            PathRoute route = string.IsNullOrWhiteSpace(routeName)
                ? TryFindAutoTestRoute(routes, pathType)
                : routes.FirstOrDefault(r => string.Equals(r.Name, routeName, StringComparison.OrdinalIgnoreCase));

            if (route == null)
            {
                throw new InvalidOperationException(
                    string.IsNullOrWhiteSpace(routeName)
                        ? $"找不到默认自动测试路径: {pathType}"
                        : $"找不到指定路径: {routeName}");
            }

            if (route.PathType != pathType)
            {
                throw new InvalidOperationException($"指定路径类型不匹配: 期望={pathType}, 实际={route.PathType}, 路径={route.Name}");
            }

            return route;
        }

        private static PathType ParsePathTypeOrThrow(string value, string parameterName)
        {
            if (string.IsNullOrWhiteSpace(value))
            {
                throw new InvalidOperationException($"缺少必填参数: {parameterName}");
            }

            if (!Enum.TryParse(value, true, out PathType pathType))
            {
                throw new InvalidOperationException($"无法解析路径类型: {value}");
            }

            return pathType;
        }

        private static ModelItem ResolveAnimatedObjectFromQuery(Dictionary<string, string> query)
        {
            Document activeDocument = Autodesk.Navisworks.Api.Application.ActiveDocument;
            if (activeDocument == null)
            {
                throw new InvalidOperationException("当前没有活动文档，无法选择真实物体");
            }

            string animatedObjectName = GetOptionalQueryValue(query, "animatedObjectName");
            if (string.IsNullOrWhiteSpace(animatedObjectName))
            {
                return ResolveSingleSelectedItem(activeDocument);
            }

            var matches = new List<ModelItem>();
            foreach (Model model in activeDocument.Models)
            {
                if (model?.RootItem == null)
                {
                    continue;
                }

                foreach (ModelItem item in model.RootItem.DescendantsAndSelf)
                {
                    if (item != null && string.Equals(item.DisplayName, animatedObjectName, StringComparison.OrdinalIgnoreCase))
                    {
                        matches.Add(item);
                    }
                }
            }

            if (matches.Count == 0)
            {
                throw new InvalidOperationException($"找不到指定真实物体: {animatedObjectName}");
            }

            if (matches.Count > 1)
            {
                throw new InvalidOperationException($"找到多个同名真实物体，请改用更唯一的名字: {animatedObjectName}");
            }

            return matches[0];
        }

        private static ModelItem ResolveSingleSelectedItem(Document activeDocument)
        {
            var selectedItems = activeDocument.CurrentSelection?.SelectedItems?.Cast<ModelItem>().Where(item => item != null).ToList()
                               ?? new List<ModelItem>();

            if (selectedItems.Count != 1)
            {
                throw new InvalidOperationException($"当前选择集必须且只能包含 1 个真实物体，当前数量: {selectedItems.Count}");
            }

            return selectedItems[0];
        }

        private static void SelectDocumentItem(ModelItem item)
        {
            Document activeDocument = Autodesk.Navisworks.Api.Application.ActiveDocument;
            if (activeDocument?.CurrentSelection == null)
            {
                throw new InvalidOperationException("当前文档选择集不可用");
            }

            activeDocument.CurrentSelection.Clear();
            activeDocument.CurrentSelection.Add(item);
        }

        private static PathRouteViewModel CreatePathRouteViewModel(PathRoute route)
        {
            var routeViewModel = new PathRouteViewModel(isFromDatabase: true)
            {
                Route = route,
                IsActive = true
            };

            foreach (var point in route.Points.OrderBy(p => p.Index))
            {
                routeViewModel.Points.Add(new PathPointViewModel
                {
                    Id = point.Id,
                    Name = point.Name,
                    Type = point.Type,
                    Index = point.Index,
                    X = point.X,
                    Y = point.Y,
                    Z = point.Z
                });
            }

            routeViewModel.SetTimeInfo(route.CreatedTime, route.LastModified);
            return routeViewModel;
        }

        private static int ParseTimeoutSeconds(Dictionary<string, string> query, int defaultSeconds)
        {
            string raw = GetOptionalQueryValue(query, "timeoutSeconds");
            if (string.IsNullOrWhiteSpace(raw))
            {
                return defaultSeconds;
            }

            if (!int.TryParse(raw, out int parsedSeconds) || parsedSeconds <= 0)
            {
                throw new InvalidOperationException($"无法解析 timeoutSeconds: {raw}");
            }

            return parsedSeconds;
        }

        private static bool ParseBooleanQuery(Dictionary<string, string> query, string key, bool defaultValue)
        {
            string raw = GetOptionalQueryValue(query, key);
            if (string.IsNullOrWhiteSpace(raw))
            {
                return defaultValue;
            }

            if (bool.TryParse(raw, out bool parsed))
            {
                return parsed;
            }

            if (string.Equals(raw, "1", StringComparison.OrdinalIgnoreCase) ||
                string.Equals(raw, "yes", StringComparison.OrdinalIgnoreCase) ||
                string.Equals(raw, "y", StringComparison.OrdinalIgnoreCase))
            {
                return true;
            }

            if (string.Equals(raw, "0", StringComparison.OrdinalIgnoreCase) ||
                string.Equals(raw, "no", StringComparison.OrdinalIgnoreCase) ||
                string.Equals(raw, "n", StringComparison.OrdinalIgnoreCase))
            {
                return false;
            }

            throw new InvalidOperationException($"无法解析布尔参数 {key}: {raw}");
        }

        private static IDisposable EnableAutoConfirmCollisionAnalysisDialogs()
        {
            Interlocked.Increment(ref _autoConfirmCollisionAnalysisDialogRequestCount);
            return new ActionOnDispose(() =>
            {
                if (Interlocked.Decrement(ref _autoConfirmCollisionAnalysisDialogRequestCount) < 0)
                {
                    Interlocked.Exchange(ref _autoConfirmCollisionAnalysisDialogRequestCount, 0);
                }
            });
        }

        private static IDisposable EnableAutoChooseCreateNewDetectionRecord()
        {
            Interlocked.Increment(ref _autoChooseCreateNewDetectionRecordRequestCount);
            return new ActionOnDispose(() =>
            {
                if (Interlocked.Decrement(ref _autoChooseCreateNewDetectionRecordRequestCount) < 0)
                {
                    Interlocked.Exchange(ref _autoChooseCreateNewDetectionRecordRequestCount, 0);
                }
            });
        }

        private static async Task WaitForConditionAsync(DateTime deadlineUtc, Func<bool> condition, string timeoutMessage)
        {
            while (DateTime.UtcNow < deadlineUtc)
            {
                if (condition())
                {
                    return;
                }

                await Task.Delay(300).ConfigureAwait(false);
            }

            throw new TimeoutException(timeoutMessage);
        }

        private sealed class PreparedVirtualCollisionTest
        {
            public PathType pathType { get; set; }

            public object route { get; set; }

            public object animatedObject { get; set; }
        }

        private sealed class ActionOnDispose : IDisposable
        {
            private Action _disposeAction;

            public ActionOnDispose(Action disposeAction)
            {
                _disposeAction = disposeAction;
            }

            public void Dispose()
            {
                Action disposeAction = Interlocked.Exchange(ref _disposeAction, null);
                disposeAction?.Invoke();
            }
        }

        private static async Task WriteJsonResponseAsync(StreamWriter writer, int statusCode, object payload)
        {
            string statusText = ResolveStatusText(statusCode);
            string json = JsonConvert.SerializeObject(payload, Formatting.Indented);
            byte[] bodyBytes = Encoding.UTF8.GetBytes(json);

            await writer.WriteLineAsync($"HTTP/1.1 {statusCode} {statusText}").ConfigureAwait(false);
            await writer.WriteLineAsync("Content-Type: application/json; charset=utf-8").ConfigureAwait(false);
            await writer.WriteLineAsync($"Content-Length: {bodyBytes.Length}").ConfigureAwait(false);
            await writer.WriteLineAsync("Connection: close").ConfigureAwait(false);
            await writer.WriteLineAsync().ConfigureAwait(false);
            await writer.FlushAsync().ConfigureAwait(false);

            Stream baseStream = writer.BaseStream;
            await baseStream.WriteAsync(bodyBytes, 0, bodyBytes.Length).ConfigureAwait(false);
            await baseStream.FlushAsync(cancellationToken: CancellationToken.None).ConfigureAwait(false);
        }

        private static string ResolveStatusText(int statusCode)
        {
            switch (statusCode)
            {
                case 200:
                    return "OK";
                case 400:
                    return "Bad Request";
                case 404:
                    return "Not Found";
                case 405:
                    return "Method Not Allowed";
                case 500:
                    return "Internal Server Error";
                default:
                    return "OK";
            }
        }

        public void Dispose()
        {
            Stop();
        }
    }
}