using System.Globalization;
using System.Runtime.InteropServices;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;
using SolidWorks.Interop.sldworks;
using SolidWorks.Interop.swconst;

internal static class Program
{
    [DllImport("ole32.dll", CharSet = CharSet.Unicode)]
    private static extern int CLSIDFromProgID(string progId, out Guid clsid);

    [DllImport("oleaut32.dll", PreserveSig = false)]
    [return: MarshalAs(UnmanagedType.IUnknown)]
    private static extern object GetActiveObject(ref Guid clsid, IntPtr reserved);

    private static readonly JsonSerializerOptions JsonOptions = new()
    {
        WriteIndented = true,
        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
        PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
        DictionaryKeyPolicy = JsonNamingPolicy.SnakeCaseLower
    };

    private static int Main(string[] args)
    {
        try
        {
            var request = CandidateRequest.Parse(args);
            request.ModelPath = NormalizePath(request.ModelPath);
            request.OutputDir = NormalizePath(request.OutputDir);
            request.DrawingTemplatePath = NormalizePath(request.DrawingTemplatePath);
            request.RankingJsonPath = NormalizePath(request.RankingJsonPath);
            request.StudentSignaturePath = NormalizePath(request.StudentSignaturePath);
            request.ReferenceSignaturePath = NormalizePath(request.ReferenceSignaturePath);
            request.StudentViewRegionsPath = NormalizePath(request.StudentViewRegionsPath);
            request.ReferenceViewRegionsPath = NormalizePath(request.ReferenceViewRegionsPath);
            request.OutputDwgPath = NormalizePath(request.OutputDwgPath);
            request.SectionCutSymbolsPath = NormalizePath(request.SectionCutSymbolsPath);

            if (!request.UseActiveModel && (string.IsNullOrWhiteSpace(request.ModelPath) || !File.Exists(request.ModelPath)))
                throw new FileNotFoundException($"模型文件不存在: {request.ModelPath}");
            if (!request.UseActiveModel &&
                !request.ModelPath.EndsWith(".SLDASM", StringComparison.OrdinalIgnoreCase) &&
                !request.ModelPath.EndsWith(".SLDPRT", StringComparison.OrdinalIgnoreCase))
                throw new ArgumentException("--model 必须是 .SLDASM 或 .SLDPRT 文件。");

            if (string.IsNullOrWhiteSpace(request.OutputDir))
                request.OutputDir = Path.Combine(System.Environment.CurrentDirectory, "runtime", "solidworks-view-candidates", Path.GetFileNameWithoutExtension(request.ModelPath));
            Directory.CreateDirectory(request.OutputDir);

            var sw = ConnectSolidWorks();
            var result = Generate(sw, request);
            WriteJson(Path.Combine(request.OutputDir, "candidate-result.json"), result);
            WriteJson(Path.Combine(request.OutputDir, "candidate-views.json"), result.Candidates);

            Console.WriteLine(JsonSerializer.Serialize(result, JsonOptions));
            return result.Ok ? 0 : 1;
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine(ex);
            return 1;
        }
    }

    private static SldWorks ConnectSolidWorks()
    {
        try
        {
            var hr = CLSIDFromProgID("SldWorks.Application", out var clsid);
            if (hr < 0)
                Marshal.ThrowExceptionForHR(hr);
            var active = (SldWorks)GetActiveObject(ref clsid, IntPtr.Zero);
            active.Visible = true;
            return active;
        }
        catch
        {
            var type = Type.GetTypeFromProgID("SldWorks.Application")
                ?? throw new InvalidOperationException("无法创建 SolidWorks COM 对象。");
            var sw = (SldWorks)(Activator.CreateInstance(type)
                ?? throw new InvalidOperationException("SolidWorks COM 创建结果为空。"));
            sw.Visible = true;
            return sw;
        }
    }

    private static CandidateResult Generate(SldWorks sw, CandidateRequest request)
    {
        var started = DateTimeOffset.Now;
        var model = ResolveModel(sw, request);
        request.ModelPath = NormalizePath(Safe(() => model.GetPathName(), request.ModelPath));
        if (string.IsNullOrWhiteSpace(request.ModelPath))
            throw new InvalidOperationException("无法确定模型路径，CreateDrawViewFromModelView3 需要模型文件路径。");

        var mathUtility = sw.GetMathUtility()
            ?? throw new InvalidOperationException("SolidWorks GetMathUtility 返回空。");

        if (request.ExportActiveDrawingDwg)
        {
            var exportDrawingContext = ResolveDrawing(sw, request);
            return ExportActiveDrawingDwg(exportDrawingContext, request, started);
        }

        if (request.ListDrawingViews)
        {
            var listDrawingContext = ResolveDrawing(sw, request);
            return ListDrawingViews(listDrawingContext, request, started);
        }

        if (request.AlignMainViewOrigin)
        {
            var alignDrawingContext = ResolveDrawing(sw, request);
            return AlignPlacedMainViewToSignatureOrigin(alignDrawingContext, request, started);
        }

        if (request.AlignProjectedViewsToRegions)
        {
            var alignDrawingContext = ResolveDrawing(sw, request);
            return AlignProjectedViewToDwgRegionCenter(alignDrawingContext, request, started);
        }

        if (request.AlignSectionViewsToRegions)
        {
            var alignDrawingContext = ResolveDrawing(sw, request);
            return AlignSectionViewsToDwgRegionCenters(alignDrawingContext, request, started);
        }

        if (request.PlaceProjectedView)
        {
            var projectedDrawingContext = ResolveDrawing(sw, request);
            return PlaceProjectedView(projectedDrawingContext, request, started);
        }

        if (request.PlaceSectionViews)
        {
            var sectionDrawingContext = ResolveDrawing(sw, request);
            return PlaceSectionViews(sectionDrawingContext, request, started);
        }

        if (request.PlaceMainView && request.CandidateIndex == null)
            request.CandidateIndex = ReadBestCandidateIndex(request.RankingJsonPath);

        var candidates = BuildCandidates(request.ViewNamePrefix);
        if (request.CandidateIndex != null)
            candidates = candidates.Where(candidate => candidate.Index == request.CandidateIndex.Value).ToList();
        if (candidates.Count == 0)
            throw new InvalidOperationException($"没有找到候选视图: index={request.CandidateIndex}");
        if (request.PlaceMainView)
            RenameCandidates(candidates, request.MainViewNamePrefix);
        CreateNamedViews(model, mathUtility, candidates, request.KeepNamedViews);

        var drawingContext = ResolveDrawing(sw, request);
        var drawingModel = drawingContext.Model;
        var drawing = drawingContext.Drawing;

        if (request.ExportCandidateDwgsSequential)
        {
            CleanupCandidateDrawingViews(drawingModel, drawing, request.ViewNamePrefix);
            ExportCandidateDwgsSequential(drawingModel, drawing, request.ModelPath, candidates, request);

            if (!request.KeepNamedViews)
                DeleteNamedViews(model, candidates);

            return new CandidateResult
            {
                Ok = true,
                Message = "已串行导出 24 个候选视图 DWG；每次只插入并保存一个候选视图。",
                ModelPath = request.ModelPath,
                DrawingTemplatePath = drawingContext.TemplatePath,
                DrawingPath = drawingContext.DrawingPath,
                UsedActiveDrawing = request.UseActiveDrawing,
                OutputDir = request.OutputDir,
                StartedAt = started,
                CompletedAt = DateTimeOffset.Now,
                Candidates = candidates,
                Artifacts = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
                {
                    ["candidate_dwg_dir"] = CandidateDwgDirectory(request),
                    ["candidate_dwg_count"] = candidates.Count(candidate => candidate.DwgSaveOk && File.Exists(candidate.DwgPath)).ToString(CultureInfo.InvariantCulture)
                },
                SourceApis =
                [
                    "IModelView.Orientation3",
                    "IModelDoc2.NameView",
                    "IDrawingDoc.CreateDrawViewFromModelView3",
                    "IModelDocExtension.SaveAs",
                    "IModelDocExtension.SelectByID2",
                    "IModelDocExtension.DeleteSelection2",
                    "IModelDoc2.DeleteNamedView"
                ]
            };
        }

        if (request.PlaceMainView)
        {
            var candidate = candidates.Single();
            if (request.ReplaceExistingMainView)
                CleanupCandidateDrawingViews(drawingModel, drawing, request.MainViewNamePrefix);
            var view = InsertSingleCandidateView(drawing, request.ModelPath, candidate, request)
                ?? throw new InvalidOperationException($"插入主视图失败: {candidate.Name}");
            Safe(() => drawingModel.ForceRebuild3(false), false);
            candidate.DrawingViewName = Safe(() => view.GetName2(), candidate.DrawingViewName);
            candidate.OrientationName = Safe(() => view.GetOrientationName(), candidate.OrientationName);
            candidate.Position = DoubleList(Safe(() => view.Position, null));
            candidate.ScaleDecimal = Safe(() => view.ScaleDecimal, 0.0);
            candidate.UseSheetScale = Safe(() => view.UseSheetScale, 0);

            return new CandidateResult
            {
                Ok = true,
                Message = "已在当前 SolidWorks 工程图中放置最优主视图。",
                ModelPath = request.ModelPath,
                DrawingTemplatePath = drawingContext.TemplatePath,
                DrawingPath = drawingContext.DrawingPath,
                UsedActiveDrawing = request.UseActiveDrawing,
                OutputDir = request.OutputDir,
                StartedAt = started,
                CompletedAt = DateTimeOffset.Now,
                Candidates = candidates,
                Artifacts = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
                {
                    ["placed_main_view_name"] = candidate.DrawingViewName,
                    ["placed_orientation_name"] = candidate.OrientationName,
                    ["candidate_index"] = candidate.Index.ToString(CultureInfo.InvariantCulture),
                    ["direction_name"] = candidate.DirectionName,
                    ["roll_degrees"] = candidate.RollDeg.ToString(CultureInfo.InvariantCulture),
                    ["scale_decimal"] = candidate.ScaleDecimal.ToString(CultureInfo.InvariantCulture)
                },
                SourceApis =
                [
                    "IModelView.Orientation3",
                    "IModelDoc2.NameView",
                    "IDrawingDoc.CreateDrawViewFromModelView3",
                    "IModelDocExtension.SelectByID2",
                    "IModelDocExtension.DeleteSelection2"
                ]
            };
        }

        if (DateTimeOffset.Now.Ticks >= 0)
        throw new InvalidOperationException("当前流程只支持 --export-candidate-dwgs-sequential：每次插入一个候选视图、另存为一个 DWG、删除该视图，再交给 AutoCAD 提取和排序。旧的 SolidWorks 工程图 polyline 直接签名/排序方法已废弃。");

        return new CandidateResult
        {
            Ok = true,
            Message = "已生成 24 个 SolidWorks 候选主视图。",
            ModelPath = request.ModelPath,
            DrawingTemplatePath = drawingContext.TemplatePath,
            DrawingPath = drawingContext.DrawingPath,
            UsedActiveDrawing = request.UseActiveDrawing,
            OutputDir = request.OutputDir,
            StartedAt = started,
            CompletedAt = DateTimeOffset.Now,
            Candidates = candidates,
            SourceApis =
            [
                "IModelView.Orientation3",
                "IModelDoc2.NameView",
                "IDrawingDoc.CreateDrawViewFromModelView3",
                "ISldWorks.IGetFirstDocument2",
                "IModelDoc2.DeleteNamedView"
            ]
        };
    }

    private static ModelDoc2 ResolveModel(SldWorks sw, CandidateRequest request)
    {
        if (request.UseActiveModel)
        {
            var active = sw.IActiveDoc2 as ModelDoc2;
            if (active != null && IsPartOrAssembly(active))
                return active;

            var openModel = FindOpenModel(sw);
            if (openModel != null)
                return openModel;

            throw new InvalidOperationException("没有找到已打开的零件或装配体。请先打开模型，或使用 --model 指定路径。");
        }

        return OpenModel(sw, request.ModelPath);
    }

    private static ModelDoc2 OpenModel(SldWorks sw, string modelPath)
    {
        var extension = Path.GetExtension(modelPath);
        var type = extension.Equals(".SLDASM", StringComparison.OrdinalIgnoreCase)
            ? (int)swDocumentTypes_e.swDocASSEMBLY
            : (int)swDocumentTypes_e.swDocPART;
        var errors = 0;
        var warnings = 0;
        var model = sw.OpenDoc6(
            modelPath,
            type,
            (int)swOpenDocOptions_e.swOpenDocOptions_Silent,
            "",
            ref errors,
            ref warnings) as ModelDoc2;
        if (model == null)
            throw new InvalidOperationException($"打开模型失败: errors={errors}, warnings={warnings}");

        Safe(() =>
        {
            var activateErrors = 0;
            sw.ActivateDoc3(model.GetTitle(), false, 0, ref activateErrors);
            return activateErrors;
        }, 0);
        return model;
    }

    private static DrawingContext ResolveDrawing(SldWorks sw, CandidateRequest request)
    {
        if (request.UseActiveDrawing)
        {
            var drawingModel = FindOpenDrawing(sw)
                ?? throw new InvalidOperationException("没有找到已打开的工程图。请先打开 .SLDDRW，再运行 --use-active-drawing。");
            return new DrawingContext(
                drawingModel,
                drawingModel as DrawingDoc ?? throw new InvalidOperationException("已打开文档不是 DrawingDoc。"),
                "",
                Safe(() => drawingModel.GetPathName(), ""));
        }

        var templatePath = ResolveTemplatePath(sw, request);
        Safe(() =>
        {
            sw.PreSelectDwgTemplateSize((int)swDwgPaperSizes_e.swDwgPaperA2size, "");
            return true;
        }, false);
        var drawingModelNew = sw.NewDocument(
                templatePath,
                (int)swDwgPaperSizes_e.swDwgPaperA2size,
                request.SheetWidthM,
                request.SheetHeightM) as ModelDoc2
            ?? throw new InvalidOperationException("SolidWorks NewDocument 未返回工程图。");
        var drawing = drawingModelNew as DrawingDoc
            ?? throw new InvalidOperationException("新建文档不是 DrawingDoc。");
        return new DrawingContext(drawingModelNew, drawing, templatePath, Safe(() => drawingModelNew.GetPathName(), ""));
    }

    private static ModelDoc2? FindOpenDrawing(SldWorks sw)
    {
        var active = sw.IActiveDoc2 as ModelDoc2;
        if (active != null && Safe(() => active.GetType(), 0) == (int)swDocumentTypes_e.swDocDRAWING)
            return active;

        var doc = sw.IGetFirstDocument2();
        while (doc != null)
        {
            if (Safe(() => doc.GetType(), 0) == (int)swDocumentTypes_e.swDocDRAWING)
                return doc;
            doc = Safe(() => doc.IGetNext(), null);
        }
        return null;
    }

    private static ModelDoc2? FindOpenModel(SldWorks sw)
    {
        var doc = sw.IGetFirstDocument2();
        while (doc != null)
        {
            if (IsPartOrAssembly(doc))
                return doc;
            doc = Safe(() => doc.IGetNext(), null);
        }
        return null;
    }

    private static bool IsPartOrAssembly(ModelDoc2 doc)
    {
        var type = Safe(() => doc.GetType(), 0);
        return type == (int)swDocumentTypes_e.swDocPART || type == (int)swDocumentTypes_e.swDocASSEMBLY;
    }

    private static string ResolveTemplatePath(SldWorks sw, CandidateRequest request)
    {
        if (!string.IsNullOrWhiteSpace(request.DrawingTemplatePath))
        {
            if (!File.Exists(request.DrawingTemplatePath))
                throw new FileNotFoundException($"工程图模板不存在: {request.DrawingTemplatePath}");
            return request.DrawingTemplatePath;
        }

        var templatePath = sw.GetDocumentTemplate((int)swDocumentTypes_e.swDocDRAWING, "", 0, request.SheetWidthM, request.SheetHeightM);
        if (string.IsNullOrWhiteSpace(templatePath) || !File.Exists(templatePath))
            throw new FileNotFoundException($"无法解析 SolidWorks 工程图模板: {templatePath}");
        return templatePath;
    }

    private static List<ViewCandidate> BuildCandidates(string prefix)
    {
        var directions = new[]
        {
            ("px", new[] { 1.0, 0.0, 0.0 }),
            ("nx", new[] { -1.0, 0.0, 0.0 }),
            ("py", new[] { 0.0, 1.0, 0.0 }),
            ("ny", new[] { 0.0, -1.0, 0.0 }),
            ("pz", new[] { 0.0, 0.0, 1.0 }),
            ("nz", new[] { 0.0, 0.0, -1.0 })
        };
        var rolls = new[] { 0, 90, 180, 270 };
        var result = new List<ViewCandidate>();
        var index = 0;
        foreach (var (directionName, direction) in directions)
        {
            foreach (var roll in rolls)
            {
                index++;
                var name = $"{prefix}_{index:00}_{directionName}_r{roll}";
                var basis = BuildBasis(direction, roll);
                result.Add(new ViewCandidate
                {
                    Index = index,
                    Name = name,
                    DirectionName = directionName,
                    RollDeg = roll,
                    ViewDirection = direction.ToList(),
                    BasisU = basis.U.ToList(),
                    BasisV = basis.V.ToList(),
                    BasisD = basis.D.ToList()
                });
            }
        }
        return result;
    }

    private static void RenameCandidates(List<ViewCandidate> candidates, string prefix)
    {
        foreach (var candidate in candidates)
            candidate.Name = $"{prefix}_{candidate.Index:00}_{candidate.DirectionName}_r{candidate.RollDeg}";
    }

    private static int ReadBestCandidateIndex(string rankingJsonPath)
    {
        if (string.IsNullOrWhiteSpace(rankingJsonPath))
            throw new ArgumentException("--place-main-view 需要同时传 --candidate-index，或传 --ranking-json 自动读取 rank 1。");
        if (!File.Exists(rankingJsonPath))
            throw new FileNotFoundException($"排序结果文件不存在: {rankingJsonPath}");

        using var document = JsonDocument.Parse(File.ReadAllText(rankingJsonPath));
        if (!document.RootElement.TryGetProperty("ranking", out var ranking) ||
            ranking.ValueKind != JsonValueKind.Array ||
            ranking.GetArrayLength() == 0)
            throw new InvalidOperationException($"排序结果中没有 ranking 数组: {rankingJsonPath}");

        var best = ranking.EnumerateArray()
            .OrderBy(item => item.TryGetProperty("rank", out var rank) && rank.TryGetInt32(out var value) ? value : int.MaxValue)
            .First();

        if (!best.TryGetProperty("index", out var indexElement) || !indexElement.TryGetInt32(out var index))
            throw new InvalidOperationException($"排序第一名缺少 index 字段: {rankingJsonPath}");
        return index;
    }

    private static CandidateResult AlignPlacedMainViewToSignatureOrigin(
        DrawingContext drawingContext,
        CandidateRequest request,
        DateTimeOffset started)
    {
        var studentOrigin = ReadSignatureOrigin(request.StudentSignaturePath, "student");
        if (string.IsNullOrWhiteSpace(request.ReferenceSignaturePath))
            throw new ArgumentException("--align-main-view-origin 只保留 DWG 对比路径，必须提供 --reference-signature。该文件应来自 SW 工程图导出 DWG 后的 AutoCAD 提取结果。");
        var referenceOrigin = ReadSignatureOrigin(request.ReferenceSignaturePath, "reference");
        var view = FindMainDrawingView(drawingContext.Drawing, request)
            ?? throw new InvalidOperationException($"没有找到需要平移的主视图。prefix={request.MainViewNamePrefix}, orientation={request.MainViewOrientationName}");
        var viewName = Safe(() => Convert.ToString(view.GetName2(), CultureInfo.InvariantCulture) ?? "", "");
        var orientationName = Safe(() => Convert.ToString(view.GetOrientationName(), CultureInfo.InvariantCulture) ?? "", "");

        var deltaMmX = studentOrigin.X - referenceOrigin.X;
        var deltaMmY = studentOrigin.Y - referenceOrigin.Y;
        var appliedDeltaMmX = ShouldApplyAxis(request.AlignmentAxis, "x") ? deltaMmX : 0.0;
        var appliedDeltaMmY = ShouldApplyAxis(request.AlignmentAxis, "y") ? deltaMmY : 0.0;
        var deltaM = new[] { appliedDeltaMmX / 1000.0, appliedDeltaMmY / 1000.0 };

        var before = DoubleList(Safe<object?>(() => view.Position, null));
        if (before.Count < 2)
            throw new InvalidOperationException($"无法读取主视图 Position: {viewName}");

        var after = new[] { before[0] + deltaM[0], before[1] + deltaM[1] };
        Safe(() =>
        {
            view.Position = after;
            return true;
        }, false);
        Safe(() => drawingContext.Model.ForceRebuild3(false), false);
        var actualAfter = DoubleList(Safe<object?>(() => view.Position, null));

        return new CandidateResult
        {
            Ok = true,
            Message = "已按学生图左侧竖直线最上点整体平移 SolidWorks 主视图。",
            ModelPath = request.ModelPath,
            DrawingTemplatePath = drawingContext.TemplatePath,
            DrawingPath = drawingContext.DrawingPath,
            UsedActiveDrawing = request.UseActiveDrawing,
            OutputDir = request.OutputDir,
            StartedAt = started,
            CompletedAt = DateTimeOffset.Now,
            Artifacts = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
            {
                ["main_view_name"] = viewName,
                ["main_view_orientation_name"] = orientationName,
                ["student_origin_mm"] = $"{studentOrigin.X.ToString(CultureInfo.InvariantCulture)},{studentOrigin.Y.ToString(CultureInfo.InvariantCulture)}",
                ["reference_origin_mm"] = $"{referenceOrigin.X.ToString(CultureInfo.InvariantCulture)},{referenceOrigin.Y.ToString(CultureInfo.InvariantCulture)}",
                ["reference_origin_source"] = request.ReferenceSignaturePath,
                ["delta_mm"] = $"{deltaMmX.ToString(CultureInfo.InvariantCulture)},{deltaMmY.ToString(CultureInfo.InvariantCulture)}",
                ["alignment_axis"] = request.AlignmentAxis,
                ["applied_delta_mm"] = $"{appliedDeltaMmX.ToString(CultureInfo.InvariantCulture)},{appliedDeltaMmY.ToString(CultureInfo.InvariantCulture)}",
                ["delta_m"] = $"{deltaM[0].ToString(CultureInfo.InvariantCulture)},{deltaM[1].ToString(CultureInfo.InvariantCulture)}",
                ["position_before_m"] = $"{before[0].ToString(CultureInfo.InvariantCulture)},{before[1].ToString(CultureInfo.InvariantCulture)}",
                ["position_after_m"] = actualAfter.Count >= 2
                    ? $"{actualAfter[0].ToString(CultureInfo.InvariantCulture)},{actualAfter[1].ToString(CultureInfo.InvariantCulture)}"
                    : $"{after[0].ToString(CultureInfo.InvariantCulture)},{after[1].ToString(CultureInfo.InvariantCulture)}"
            },
            SourceApis =
            [
                "IView.Position",
                "IView.GetOrientationName",
                "IView.GetName2",
                "IModelDoc2.ForceRebuild3"
            ]
        };
    }

    private static bool ShouldApplyAxis(string axis, string component)
    {
        if (string.IsNullOrWhiteSpace(axis))
            return true;
        if (string.Equals(axis, "xy", StringComparison.OrdinalIgnoreCase))
            return true;
        return string.Equals(axis, component, StringComparison.OrdinalIgnoreCase);
    }

    private static CandidateResult AlignProjectedViewToDwgRegionCenter(
        DrawingContext drawingContext,
        CandidateRequest request,
        DateTimeOffset started)
    {
        if (string.IsNullOrWhiteSpace(request.StudentViewRegionsPath))
            throw new ArgumentException("--align-projected-views-to-regions requires --student-view-regions.");
        if (string.IsNullOrWhiteSpace(request.ReferenceViewRegionsPath))
            throw new ArgumentException("--align-projected-views-to-regions requires --reference-view-regions.");

        var direction = NormalizeProjectedDirection(request.ProjectedViewDirection);
        var regionKind = ProjectedDirectionToRegionKind(direction);
        var student = ReadOrthographicViewRegionCenter(request.StudentViewRegionsPath, regionKind, "student");
        var reference = ReadOrthographicViewRegionCenter(request.ReferenceViewRegionsPath, regionKind, "reference");
        var viewName = FirstNonEmpty(
            request.ProjectedViewName,
            direction == "right" ? "agent4_right_projected_view" : "agent4_bottom_projected_view");
        var view = FindDrawingView(drawingContext.Drawing, viewName)
            ?? throw new InvalidOperationException($"Projected drawing view not found: {viewName}");

        var deltaMmX = student.CenterX - reference.CenterX;
        var deltaMmY = student.CenterY - reference.CenterY;
        var appliedDeltaMmX = ShouldApplyAxis(request.AlignmentAxis, "x") ? deltaMmX : 0.0;
        var appliedDeltaMmY = ShouldApplyAxis(request.AlignmentAxis, "y") ? deltaMmY : 0.0;
        var before = DoubleList(Safe<object?>(() => view.Position, null));
        if (before.Count < 2)
            throw new InvalidOperationException($"Cannot read projected view Position: {viewName}");

        Safe(() =>
        {
            view.PositionLocked = false;
            return true;
        }, false);
        var after = new[] { before[0] + appliedDeltaMmX / 1000.0, before[1] + appliedDeltaMmY / 1000.0 };
        Safe(() =>
        {
            view.Position = after;
            return true;
        }, false);
        Safe(() => drawingContext.Model.ForceRebuild3(false), false);
        var actualAfter = DoubleList(Safe<object?>(() => view.Position, null));

        var reportPath = Path.Combine(request.OutputDir, "aligned-projected-view.json");
        WriteJson(reportPath, new Dictionary<string, object?>
        {
            ["direction"] = direction,
            ["region_kind"] = regionKind,
            ["view_name"] = viewName,
            ["student_view_regions"] = request.StudentViewRegionsPath,
            ["reference_view_regions"] = request.ReferenceViewRegionsPath,
            ["alignment_axis"] = request.AlignmentAxis,
            ["student_center_mm"] = new[] { student.CenterX, student.CenterY },
            ["reference_center_mm"] = new[] { reference.CenterX, reference.CenterY },
            ["delta_mm"] = new[] { deltaMmX, deltaMmY },
            ["applied_delta_mm"] = new[] { appliedDeltaMmX, appliedDeltaMmY },
            ["position_before_m"] = before,
            ["position_after_m"] = actualAfter.Count >= 2 ? actualAfter : after,
            ["kept_projection_relation"] = true
        });

        return new CandidateResult
        {
            Ok = true,
            Message = "Aligned projected drawing view to DWG-extracted orthographic region center.",
            ModelPath = request.ModelPath,
            DrawingTemplatePath = drawingContext.TemplatePath,
            DrawingPath = drawingContext.DrawingPath,
            UsedActiveDrawing = request.UseActiveDrawing,
            OutputDir = request.OutputDir,
            StartedAt = started,
            CompletedAt = DateTimeOffset.Now,
            Artifacts = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
            {
                ["student_view_regions"] = request.StudentViewRegionsPath,
                ["reference_view_regions"] = request.ReferenceViewRegionsPath,
                ["aligned_projected_view"] = reportPath,
                ["direction"] = direction,
                ["region_kind"] = regionKind,
                ["view_name"] = viewName,
                ["delta_mm"] = $"{deltaMmX.ToString(CultureInfo.InvariantCulture)},{deltaMmY.ToString(CultureInfo.InvariantCulture)}",
                ["applied_delta_mm"] = $"{appliedDeltaMmX.ToString(CultureInfo.InvariantCulture)},{appliedDeltaMmY.ToString(CultureInfo.InvariantCulture)}"
            },
            SourceApis =
            [
                "IView.Position",
                "IView.GetName2",
                "IModelDoc2.ForceRebuild3"
            ]
        };
    }

    private static CandidateResult AlignSectionViewsToDwgRegionCenters(
        DrawingContext drawingContext,
        CandidateRequest request,
        DateTimeOffset started)
    {
        if (string.IsNullOrWhiteSpace(request.StudentViewRegionsPath))
            throw new ArgumentException("--align-section-views-to-regions requires --student-view-regions.");
        if (string.IsNullOrWhiteSpace(request.ReferenceViewRegionsPath))
            throw new ArgumentException("--align-section-views-to-regions requires --reference-view-regions.");

        var studentCenters = ReadSectionViewRegionCenters(request.StudentViewRegionsPath, "student");
        var referenceCenters = ReadSectionViewRegionCenters(request.ReferenceViewRegionsPath, "reference");
        if (!string.IsNullOrWhiteSpace(request.SectionLabel))
        {
            var requestedLabel = NormalizeSectionRegionLabel(request.SectionLabel);
            studentCenters = studentCenters
                .Where(item => string.Equals(NormalizeSectionRegionLabel(item.Label), requestedLabel, StringComparison.OrdinalIgnoreCase))
                .ToList();
            referenceCenters = referenceCenters
                .Where(item => string.Equals(NormalizeSectionRegionLabel(item.Label), requestedLabel, StringComparison.OrdinalIgnoreCase))
                .ToList();
        }

        var referenceByLabel = referenceCenters
            .GroupBy(item => NormalizeSectionRegionLabel(item.Label), StringComparer.OrdinalIgnoreCase)
            .ToDictionary(group => group.Key, group => group.First(), StringComparer.OrdinalIgnoreCase);
        var matches = studentCenters
            .Select(student => new
            {
                Student = student,
                Reference = referenceByLabel.TryGetValue(NormalizeSectionRegionLabel(student.Label), out var reference) ? reference : null
            })
            .Where(item => item.Reference != null)
            .ToList();
        if (matches.Count == 0)
            throw new InvalidOperationException($"No matching section view labels between {request.StudentViewRegionsPath} and {request.ReferenceViewRegionsPath}");

        var averageDeltaMmX = matches.Average(item => item.Student.CenterX - item.Reference!.CenterX);
        var averageDeltaMmY = matches.Average(item => item.Student.CenterY - item.Reference!.CenterY);
        var deltasByLabel = matches.ToDictionary(
            item => NormalizeSectionRegionLabel(item.Student.Label),
            item =>
            {
                var deltaMmX = item.Student.CenterX - item.Reference!.CenterX;
                var deltaMmY = item.Student.CenterY - item.Reference.CenterY;
                var appliedDeltaMmX = ShouldApplyAxis(request.AlignmentAxis, "x") ? deltaMmX : 0.0;
                var appliedDeltaMmY = ShouldApplyAxis(request.AlignmentAxis, "y") ? deltaMmY : 0.0;
                return new SectionRegionDelta(deltaMmX, deltaMmY, appliedDeltaMmX, appliedDeltaMmY);
            },
            StringComparer.OrdinalIgnoreCase);
        var matchedLabelKeys = matches
            .Select(item => NormalizeSectionRegionLabel(item.Student.Label))
            .ToHashSet(StringComparer.OrdinalIgnoreCase);

        var moved = new List<Dictionary<string, object?>>();
        var viewObj = drawingContext.Drawing.GetFirstView();
        while (viewObj is View view)
        {
            var viewName = Safe(() => view.GetName2(), "");
            var type = Safe(() => view.Type, 0);
            var matchedLabel = matchedLabelKeys.FirstOrDefault(label =>
                IsLikelySectionViewForLabel(viewName, SectionViewLabelToken(label)));
            if (type == (int)swDrawingViewTypes_e.swDrawingSectionView &&
                !string.IsNullOrWhiteSpace(matchedLabel) &&
                deltasByLabel.TryGetValue(matchedLabel, out var delta))
            {
                var before = DoubleList(Safe<object?>(() => view.Position, null));
                if (before.Count >= 2)
                {
                    var after = new[] { before[0] + delta.AppliedDeltaMmX / 1000.0, before[1] + delta.AppliedDeltaMmY / 1000.0 };
                    Safe(() =>
                    {
                        view.PositionLocked = false;
                        return true;
                    }, false);
                    var removedAlignment = Safe(() =>
                    {
                        view.RemoveAlignment();
                        return true;
                    }, false);
                    Safe(() =>
                    {
                        view.Position = after;
                        return true;
                    }, false);
                    var actualAfter = DoubleList(Safe<object?>(() => view.Position, null));
                    moved.Add(new Dictionary<string, object?>
                    {
                        ["label"] = matchedLabel,
                        ["view_name"] = viewName,
                        ["delta_mm"] = new[] { delta.DeltaMmX, delta.DeltaMmY },
                        ["applied_delta_mm"] = new[] { delta.AppliedDeltaMmX, delta.AppliedDeltaMmY },
                        ["remove_alignment_called"] = removedAlignment,
                        ["position_before_m"] = before,
                        ["position_after_m"] = actualAfter.Count >= 2 ? actualAfter : after
                    });
                }
            }

            viewObj = view.GetNextView();
        }

        if (moved.Count == 0)
            throw new InvalidOperationException($"No SolidWorks section drawing views matched labels: {string.Join(",", matchedLabelKeys)}");

        Safe(() => drawingContext.Model.ForceRebuild3(false), false);
        var reportPath = Path.Combine(request.OutputDir, "aligned-section-views.json");
        WriteJson(reportPath, new Dictionary<string, object?>
        {
            ["student_view_regions"] = request.StudentViewRegionsPath,
            ["reference_view_regions"] = request.ReferenceViewRegionsPath,
            ["alignment_axis"] = request.AlignmentAxis,
            ["matched_section_count"] = matches.Count,
            ["average_delta_mm"] = new[] { averageDeltaMmX, averageDeltaMmY },
            ["matched_regions"] = matches.Select(item => new Dictionary<string, object?>
            {
                ["label"] = item.Student.Label,
                ["student_center_mm"] = new[] { item.Student.CenterX, item.Student.CenterY },
                ["reference_center_mm"] = new[] { item.Reference!.CenterX, item.Reference.CenterY },
                ["delta_mm"] = new[] { item.Student.CenterX - item.Reference.CenterX, item.Student.CenterY - item.Reference.CenterY }
            }).ToList(),
            ["moved_views"] = moved
        });

        return new CandidateResult
        {
            Ok = true,
            Message = "Aligned SolidWorks section drawing views to DWG-extracted section region centers.",
            ModelPath = request.ModelPath,
            DrawingTemplatePath = drawingContext.TemplatePath,
            DrawingPath = drawingContext.DrawingPath,
            UsedActiveDrawing = request.UseActiveDrawing,
            OutputDir = request.OutputDir,
            StartedAt = started,
            CompletedAt = DateTimeOffset.Now,
            Artifacts = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
            {
                ["student_view_regions"] = request.StudentViewRegionsPath,
                ["reference_view_regions"] = request.ReferenceViewRegionsPath,
                ["aligned_section_views"] = reportPath,
                ["matched_section_count"] = matches.Count.ToString(CultureInfo.InvariantCulture),
                ["moved_view_count"] = moved.Count.ToString(CultureInfo.InvariantCulture),
                ["average_delta_mm"] = $"{averageDeltaMmX.ToString(CultureInfo.InvariantCulture)},{averageDeltaMmY.ToString(CultureInfo.InvariantCulture)}"
            },
            SourceApis =
            [
                "IView.Position",
                "IView.GetName2",
                "IView.Type",
                "IModelDoc2.ForceRebuild3"
            ]
        };
    }

    private static List<SectionRegionCenter> ReadSectionViewRegionCenters(string path, string label)
    {
        if (!File.Exists(path))
            throw new FileNotFoundException($"{label} view-regions file not found: {path}");

        using var document = JsonDocument.Parse(File.ReadAllText(path));
        var root = document.RootElement;
        if (!root.TryGetProperty("section_views", out var sectionViews) || sectionViews.ValueKind != JsonValueKind.Array)
            throw new InvalidOperationException($"{label} view-regions missing section_views array: {path}");

        var result = new List<SectionRegionCenter>();
        foreach (var item in sectionViews.EnumerateArray())
        {
            if (!ReadBool(item, "ok"))
                continue;
            var sectionLabel = ReadString(item, "label");
            if (string.IsNullOrWhiteSpace(sectionLabel))
                continue;
            if (!item.TryGetProperty("bbox", out var bbox) ||
                !TryReadJsonDouble(bbox, "center_x", out var centerX) ||
                !TryReadJsonDouble(bbox, "center_y", out var centerY))
                continue;
            result.Add(new SectionRegionCenter(sectionLabel, centerX, centerY));
        }

        if (result.Count == 0)
            throw new InvalidOperationException($"{label} view-regions has no ok section view centers: {path}");
        return result;
    }

    private static OrthographicRegionCenter ReadOrthographicViewRegionCenter(string path, string kind, string label)
    {
        if (!File.Exists(path))
            throw new FileNotFoundException($"{label} view-regions file not found: {path}");

        using var document = JsonDocument.Parse(File.ReadAllText(path));
        var root = document.RootElement;
        if (!root.TryGetProperty("orthographic_views", out var views) || views.ValueKind != JsonValueKind.Array)
            throw new InvalidOperationException($"{label} view-regions missing orthographic_views array: {path}");

        foreach (var item in views.EnumerateArray())
        {
            if (!ReadBool(item, "ok"))
                continue;
            if (!string.Equals(ReadString(item, "kind"), kind, StringComparison.OrdinalIgnoreCase))
                continue;
            if (!item.TryGetProperty("bbox", out var bbox) ||
                !TryReadJsonDouble(bbox, "center_x", out var centerX) ||
                !TryReadJsonDouble(bbox, "center_y", out var centerY))
                continue;
            return new OrthographicRegionCenter(kind, centerX, centerY);
        }

        throw new InvalidOperationException($"{label} view-regions has no ok orthographic region kind={kind}: {path}");
    }

    private static string NormalizeProjectedDirection(string value)
    {
        var direction = string.IsNullOrWhiteSpace(value) ? "down" : value.Trim().ToLowerInvariant();
        return direction switch
        {
            "down" or "bottom" or "俯视图" => "down",
            "right" or "右视图" => "right",
            _ => throw new ArgumentException($"unsupported projected view direction: {value}")
        };
    }

    private static string ProjectedDirectionToRegionKind(string direction) =>
        NormalizeProjectedDirection(direction) == "right"
            ? "right_of_main_view_candidate"
            : "bottom_view_candidate";

    private static bool TryReadJsonDouble(JsonElement element, string propertyName, out double value)
    {
        value = 0.0;
        return element.ValueKind == JsonValueKind.Object &&
               element.TryGetProperty(propertyName, out var property) &&
               property.ValueKind == JsonValueKind.Number &&
               property.TryGetDouble(out value);
    }

    private static string NormalizeSectionRegionLabel(string label)
    {
        var cleaned = Regex.Replace(label.Trim().ToUpperInvariant(), @"\s+", "", RegexOptions.CultureInvariant);
        var match = Regex.Match(cleaned, @"^([A-Z0-9]{1,4})(?:-\1)?$", RegexOptions.CultureInvariant);
        return match.Success ? $"{match.Groups[1].Value}-{match.Groups[1].Value}" : cleaned;
    }

    private static string SectionViewLabelToken(string normalizedLabel)
    {
        var index = normalizedLabel.IndexOf('-', StringComparison.Ordinal);
        return index > 0 ? normalizedLabel[..index] : normalizedLabel;
    }

    private static CandidateResult ListDrawingViews(
        DrawingContext drawingContext,
        CandidateRequest request,
        DateTimeOffset started)
    {
        var views = new List<Dictionary<string, object?>>();
        var viewObj = drawingContext.Drawing.GetFirstView();
        while (viewObj is View view)
        {
            var name = Safe(() => view.GetName2(), "");
            var orientationName = Safe(() => view.GetOrientationName(), "");
            views.Add(new Dictionary<string, object?>
            {
                ["name"] = name,
                ["orientation_name"] = orientationName,
                ["type"] = Safe(() => view.Type, 0),
                ["position_m"] = DoubleList(Safe<object?>(() => view.Position, null)),
                ["outline_m"] = DoubleList(Safe<object?>(() => view.GetOutline(), null)),
                ["scale_decimal"] = Safe(() => view.ScaleDecimal, 0.0),
                ["use_sheet_scale"] = Safe(() => view.UseSheetScale, 0)
            });
            viewObj = view.GetNextView();
        }

        var outputPath = Path.Combine(request.OutputDir, "drawing-views.json");
        WriteJson(outputPath, views);
        return new CandidateResult
        {
            Ok = true,
            Message = "Listed drawing views from the current SolidWorks drawing.",
            ModelPath = request.ModelPath,
            DrawingTemplatePath = drawingContext.TemplatePath,
            DrawingPath = drawingContext.DrawingPath,
            UsedActiveDrawing = request.UseActiveDrawing,
            OutputDir = request.OutputDir,
            StartedAt = started,
            CompletedAt = DateTimeOffset.Now,
            Artifacts = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
            {
                ["drawing_views"] = outputPath,
                ["drawing_view_count"] = views.Count.ToString(CultureInfo.InvariantCulture)
            },
            SourceApis =
            [
                "IDrawingDoc.GetFirstView",
                "IView.GetName2",
                "IView.GetOrientationName",
                "IView.Position",
                "IView.GetOutline"
            ]
        };
    }

    private static CandidateResult ExportActiveDrawingDwg(
        DrawingContext drawingContext,
        CandidateRequest request,
        DateTimeOffset started)
    {
        var dwgPath = request.OutputDwgPath;
        if (string.IsNullOrWhiteSpace(dwgPath))
        {
            var baseName = !string.IsNullOrWhiteSpace(drawingContext.DrawingPath)
                ? Path.GetFileNameWithoutExtension(drawingContext.DrawingPath)
                : "active-solidworks-drawing";
            dwgPath = Path.Combine(request.OutputDir, SanitizeFileName(baseName) + ".dwg");
        }

        var rebuildAttempt = 0;
        var maxRebuildAttempts = Math.Max(0, request.CandidateRebuildRetryCount);
        var save = new SaveResult(false, 0, 0);
        while (maxRebuildAttempts == 0 || rebuildAttempt < maxRebuildAttempts)
        {
            rebuildAttempt++;
            Safe(() => drawingContext.Model.ForceRebuild3(false), false);
            WaitBeforeNextCandidateAttempt(request);

            save = SaveAsWithRetries(drawingContext.Model, dwgPath, request.SaveRetryCount, request.SaveRetryDelayMs);
            if (save.Ok)
                break;

            Console.Error.WriteLine(
                $"当前工程图 DWG 导出失败，准备重建后重试：attempt={rebuildAttempt}, errors={save.Errors}, warnings={save.Warnings}");
        }

        return new CandidateResult
        {
            Ok = save.Ok,
            Message = save.Ok ? "已导出当前 SolidWorks 工程图 DWG。" : "当前 SolidWorks 工程图 DWG 导出失败。",
            ModelPath = request.ModelPath,
            DrawingTemplatePath = drawingContext.TemplatePath,
            DrawingPath = drawingContext.DrawingPath,
            UsedActiveDrawing = request.UseActiveDrawing,
            OutputDir = request.OutputDir,
            StartedAt = started,
            CompletedAt = DateTimeOffset.Now,
            Artifacts = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
            {
                ["dwg_path"] = dwgPath,
                ["dwg_save_ok"] = save.Ok.ToString(CultureInfo.InvariantCulture),
                ["dwg_save_errors"] = save.Errors.ToString(CultureInfo.InvariantCulture),
                ["dwg_save_warnings"] = save.Warnings.ToString(CultureInfo.InvariantCulture),
                ["dwg_rebuild_attempts"] = rebuildAttempt.ToString(CultureInfo.InvariantCulture),
                ["dwg_rebuild_retry_limit"] = maxRebuildAttempts == 0 ? "unlimited" : maxRebuildAttempts.ToString(CultureInfo.InvariantCulture)
            },
            SourceApis =
            [
                "IModelDocExtension.SaveAs",
                "IModelDoc2.SaveAs4",
                "IModelDoc2.ForceRebuild3"
            ]
        };
    }

    private static CandidateResult PlaceProjectedView(
        DrawingContext drawingContext,
        CandidateRequest request,
        DateTimeOffset started)
    {
        if (string.IsNullOrWhiteSpace(request.MainViewOrientationName))
            throw new ArgumentException("--place-projected-view requires --main-view-orientation-name with the parent drawing view name or orientation name.");
        if (request.ProjectedViewXM == null || request.ProjectedViewYM == null)
            throw new ArgumentException("--place-projected-view requires --projected-view-x-m and --projected-view-y-m.");

        var parentView = FindMainDrawingView(drawingContext.Drawing, request)
            ?? throw new InvalidOperationException($"Parent drawing view not found: {request.MainViewOrientationName}");
        var parentName = Safe(() => parentView.GetName2(), "");
        var parentOrientation = Safe(() => parentView.GetOrientationName(), "");
        var parentPosition = DoubleList(Safe<object?>(() => parentView.Position, null));

        if (request.ReplaceExistingProjectedView && !string.IsNullOrWhiteSpace(request.ProjectedViewName))
        {
            DeleteDrawingView(drawingContext.Model, new ViewCandidate
            {
                DrawingViewName = request.ProjectedViewName,
                OrientationName = request.ProjectedViewName,
                Name = request.ProjectedViewName
            });
        }

        drawingContext.Model.ClearSelection2(true);
        var selected = Safe(() => drawingContext.Model.Extension.SelectByID2(parentName, "DRAWINGVIEW", 0, 0, 0, false, 0, null, 0), false);
        if (!selected)
            selected = Safe(() => drawingContext.Model.Extension.SelectByID2(request.MainViewOrientationName, "DRAWINGVIEW", 0, 0, 0, false, 0, null, 0), false);
        if (!selected)
            throw new InvalidOperationException($"Failed to select parent drawing view: {parentName}");

        var view = drawingContext.Drawing.CreateUnfoldedViewAt3(
            request.ProjectedViewXM.Value,
            request.ProjectedViewYM.Value,
            0,
            false) as View
            ?? throw new InvalidOperationException("CreateUnfoldedViewAt3 returned null.");

        if (!string.IsNullOrWhiteSpace(request.ProjectedViewName))
            Safe(() => view.SetName2(request.ProjectedViewName), false);

        Safe(() => drawingContext.Model.ForceRebuild3(false), false);
        var viewName = Safe(() => view.GetName2(), "");
        var viewOrientation = Safe(() => view.GetOrientationName(), "");
        var viewPosition = DoubleList(Safe<object?>(() => view.Position, null));

        return new CandidateResult
        {
            Ok = true,
            Message = "Created a projected drawing view from the current main view.",
            ModelPath = request.ModelPath,
            DrawingTemplatePath = drawingContext.TemplatePath,
            DrawingPath = drawingContext.DrawingPath,
            UsedActiveDrawing = request.UseActiveDrawing,
            OutputDir = request.OutputDir,
            StartedAt = started,
            CompletedAt = DateTimeOffset.Now,
            Artifacts = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
            {
                ["parent_view_name"] = parentName,
                ["parent_view_orientation_name"] = parentOrientation,
                ["parent_view_position_m"] = parentPosition.Count >= 2
                    ? $"{parentPosition[0].ToString(CultureInfo.InvariantCulture)},{parentPosition[1].ToString(CultureInfo.InvariantCulture)}"
                    : "",
                ["projected_view_name"] = viewName,
                ["projected_view_orientation_name"] = viewOrientation,
                ["projected_view_type"] = Safe(() => view.Type, 0).ToString(CultureInfo.InvariantCulture),
                ["projected_view_position_m"] = viewPosition.Count >= 2
                    ? $"{viewPosition[0].ToString(CultureInfo.InvariantCulture)},{viewPosition[1].ToString(CultureInfo.InvariantCulture)}"
                    : "",
                ["requested_position_m"] = $"{request.ProjectedViewXM.Value.ToString(CultureInfo.InvariantCulture)},{request.ProjectedViewYM.Value.ToString(CultureInfo.InvariantCulture)}",
                ["projection_direction"] = request.ProjectedViewDirection
            },
            SourceApis =
            [
                "IModelDocExtension.SelectByID2",
                "IDrawingDoc.CreateUnfoldedViewAt3",
                "IView.SetName2",
                "IView.Position",
                "IModelDoc2.ForceRebuild3"
            ]
        };
    }

    private static CandidateResult PlaceSectionViews(
        DrawingContext drawingContext,
        CandidateRequest request,
        DateTimeOffset started)
    {
        if (string.IsNullOrWhiteSpace(request.SectionCutSymbolsPath))
            throw new ArgumentException("--place-section-views requires --section-cut-symbols.");
        if (!File.Exists(request.SectionCutSymbolsPath))
            throw new FileNotFoundException($"Section cut symbols file not found: {request.SectionCutSymbolsPath}");

        var symbols = ReadSectionCutSymbols(request.SectionCutSymbolsPath)
            .Where(symbol => symbol.Ok && string.Equals(symbol.Kind, "section_cut_symbol_pair", StringComparison.OrdinalIgnoreCase))
            .Where(symbol => string.IsNullOrWhiteSpace(request.SectionLabel) ||
                             string.Equals(symbol.Label, request.SectionLabel, StringComparison.OrdinalIgnoreCase))
            .ToList();
        if (symbols.Count == 0)
            throw new InvalidOperationException($"No section cut symbols to place. path={request.SectionCutSymbolsPath}, label={request.SectionLabel}");

        var placed = new List<Dictionary<string, object?>>();
        foreach (var symbol in symbols)
        {
            var parentView = ResolveSectionParentView(drawingContext.Drawing, request, symbol)
                ?? throw new InvalidOperationException($"Parent drawing view not found for section {symbol.Label}, view_kind={symbol.ViewKind}");
            var parentName = Safe(() => parentView.GetName2(), "");
            var parentOrientation = Safe(() => parentView.GetOrientationName(), "");
            var viewName = BuildSectionViewName(request, symbol);

            if (request.ReplaceExistingSectionViews)
            {
                DeleteExistingSectionViewsByLabel(drawingContext.Model, drawingContext.Drawing, symbol.Label);
                DeleteDrawingView(drawingContext.Model, new ViewCandidate
                {
                    DrawingViewName = viewName,
                    OrientationName = viewName,
                    Name = viewName
                });
            }

            drawingContext.Model.ClearSelection2(true);
            var activated = Safe(() => drawingContext.Drawing.ActivateView(parentName), false);
            if (!activated && !string.IsNullOrWhiteSpace(parentOrientation))
                activated = Safe(() => drawingContext.Drawing.ActivateView(parentOrientation), false);
            if (!activated)
                throw new InvalidOperationException($"Failed to activate parent drawing view: {parentName}");

            var sketchLine = BuildSectionSketchLine(parentView, symbol);
            var start = sketchLine.StartMm;
            var end = sketchLine.EndMm;
            var startM = sketchLine.StartM;
            var endM = sketchLine.EndM;
            var segment = drawingContext.Model.SketchManager.CreateLine(startM[0], startM[1], 0, endM[0], endM[1], 0)
                ?? throw new InvalidOperationException($"Failed to create section line for {symbol.Label} in {parentName}");
            var selected = Safe(() => segment.Select2(false, 0), false);
            if (!selected)
                selected = Safe(() => segment.Select(false), false);
            if (!selected)
                throw new InvalidOperationException($"Failed to select section line for {symbol.Label}");

            var placementM = ComputeSectionViewPlacement(symbol, request.SectionViewOffsetM);
            var options = BuildSectionViewOptions(symbol, request);
            var view = drawingContext.Drawing.CreateSectionViewAt5(
                placementM[0],
                placementM[1],
                0,
                symbol.Label,
                options,
                null,
                request.SectionDepthM) as View
                ?? throw new InvalidOperationException($"CreateSectionViewAt5 returned null for {symbol.Label}");

            Safe(() => view.SetName2(viewName), false);
            Safe(() => drawingContext.Model.ForceRebuild3(false), false);

            var actualName = Safe(() => view.GetName2(), viewName);
            var actualPosition = DoubleList(Safe<object?>(() => view.Position, null));
            placed.Add(new Dictionary<string, object?>
            {
                ["label"] = symbol.Label,
                ["source_parent_handle"] = symbol.ParentHandle,
                ["view_kind"] = symbol.ViewKind,
                ["parent_view_name"] = parentName,
                ["parent_view_orientation_name"] = parentOrientation,
                ["section_view_name"] = actualName,
                ["cut_line_mm"] = new Dictionary<string, object?>
                {
                    ["start"] = start,
                    ["end"] = end,
                    ["center"] = sketchLine.CenterMm,
                    ["direction"] = symbol.CutLine.Direction,
                    ["source"] = sketchLine.Source
                },
                ["cut_line_m"] = new Dictionary<string, object?>
                {
                    ["start"] = new[] { start[0] / 1000.0, start[1] / 1000.0 },
                    ["end"] = new[] { end[0] / 1000.0, end[1] / 1000.0 },
                    ["center"] = new[] { sketchLine.CenterMm[0] / 1000.0, sketchLine.CenterMm[1] / 1000.0 }
                },
                ["sketch_line_m"] = new Dictionary<string, object?>
                {
                    ["start"] = startM,
                    ["end"] = endM,
                    ["center"] = sketchLine.CenterM,
                    ["coordinate_system"] = "active_parent_drawing_view",
                    ["expected_default_arrow_direction"] = ComputeSectionLineDefaultArrowDirection(startM, endM)
                },
                ["arrow_direction"] = symbol.AverageArrowDirection,
                ["requested_position_m"] = placementM,
                ["actual_position_m"] = actualPosition,
                ["options"] = options
            });
        }

        WriteJson(Path.Combine(request.OutputDir, "placed-section-views.json"), placed);

        return new CandidateResult
        {
            Ok = true,
            Message = "Created SolidWorks section views from extracted student DWG section cut symbols.",
            ModelPath = request.ModelPath,
            DrawingTemplatePath = drawingContext.TemplatePath,
            DrawingPath = drawingContext.DrawingPath,
            UsedActiveDrawing = request.UseActiveDrawing,
            OutputDir = request.OutputDir,
            StartedAt = started,
            CompletedAt = DateTimeOffset.Now,
            Artifacts = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
            {
                ["section_cut_symbols"] = request.SectionCutSymbolsPath,
                ["section_count"] = placed.Count.ToString(CultureInfo.InvariantCulture),
                ["placed_section_views"] = Path.Combine(request.OutputDir, "placed-section-views.json")
            },
            SourceApis =
            [
                "IDrawingDoc.ActivateView",
                "ISketchManager.CreateLine",
                "ISketchSegment.Select2",
                "IDrawingDoc.CreateSectionViewAt5",
                "IView.SetName2",
                "IModelDoc2.ForceRebuild3"
            ]
        };
    }

    private static void DeleteExistingSectionViewsByLabel(ModelDoc2 drawingModel, DrawingDoc drawing, string label)
    {
        if (string.IsNullOrWhiteSpace(label))
            return;

        var toDelete = new List<string>();
        var viewObj = drawing.GetFirstView();
        while (viewObj is View view)
        {
            var name = Safe(() => view.GetName2(), "");
            var type = Safe(() => view.Type, 0);
            if (type == (int)swDrawingViewTypes_e.swDrawingSectionView &&
                IsLikelySectionViewForLabel(name, label))
            {
                toDelete.Add(name);
            }

            viewObj = view.GetNextView();
        }

        foreach (var name in toDelete.Distinct(StringComparer.OrdinalIgnoreCase))
        {
            DeleteDrawingView(drawingModel, new ViewCandidate
            {
                DrawingViewName = name,
                OrientationName = name,
                Name = name
            });
        }
    }

    private static bool IsLikelySectionViewForLabel(string viewName, string label)
    {
        if (string.IsNullOrWhiteSpace(viewName) || string.IsNullOrWhiteSpace(label))
            return false;
        var normalized = Regex.Replace(viewName, @"\s+", "", RegexOptions.CultureInvariant).ToUpperInvariant();
        var token = label.Trim().ToUpperInvariant();
        return normalized.Contains($"{token}-{token}", StringComparison.OrdinalIgnoreCase) ||
               normalized.EndsWith(token, StringComparison.OrdinalIgnoreCase);
    }

    private static View? ResolveSectionParentView(DrawingDoc drawing, CandidateRequest request, SectionCutSymbol symbol)
    {
        if (string.Equals(symbol.ViewKind, "bottom_view_candidate", StringComparison.OrdinalIgnoreCase) &&
            !string.IsNullOrWhiteSpace(request.ProjectedViewName))
        {
            return FindDrawingView(drawing, request.ProjectedViewName);
        }

        if (string.Equals(symbol.ViewKind, "main_view", StringComparison.OrdinalIgnoreCase))
            return FindMainDrawingView(drawing, request);

        return FindMainDrawingView(drawing, request)
            ?? (!string.IsNullOrWhiteSpace(request.ProjectedViewName) ? FindDrawingView(drawing, request.ProjectedViewName) : null);
    }

    private static View? FindDrawingView(DrawingDoc drawing, string nameOrOrientation)
    {
        var viewObj = drawing.GetFirstView();
        while (viewObj is View view)
        {
            var name = Safe(() => view.GetName2(), "");
            var orientationName = Safe(() => view.GetOrientationName(), "");
            if (string.Equals(name, nameOrOrientation, StringComparison.OrdinalIgnoreCase) ||
                string.Equals(orientationName, nameOrOrientation, StringComparison.OrdinalIgnoreCase))
                return view;
            viewObj = view.GetNextView();
        }

        return null;
    }

    private static string BuildSectionViewName(CandidateRequest request, SectionCutSymbol symbol)
    {
        var label = string.IsNullOrWhiteSpace(symbol.Label) ? "section" : symbol.Label.Trim();
        return $"{request.SectionViewNamePrefix}_{label}";
    }

    private static SectionSketchLine BuildSectionSketchLine(View parentView, SectionCutSymbol symbol)
    {
        var center = symbol.CutLine.Center.Count >= 2
            ? symbol.CutLine.Center
            : [
                (symbol.CutLine.Start[0] + symbol.CutLine.End[0]) / 2.0,
                (symbol.CutLine.Start[1] + symbol.CutLine.End[1]) / 2.0
            ];
        var centerM = new[] { center[0] / 1000.0, center[1] / 1000.0 };
        var parentPosition = DoubleList(Safe<object?>(() => parentView.Position, null));
        var parentX = parentPosition.Count >= 2 ? parentPosition[0] : 0.0;
        var parentY = parentPosition.Count >= 2 ? parentPosition[1] : 0.0;
        var outline = DoubleList(Safe<object?>(() => parentView.GetOutline(), null));
        if (outline.Count >= 4)
        {
            var minX = Math.Min(outline[0], outline[2]);
            var maxX = Math.Max(outline[0], outline[2]);
            var minY = Math.Min(outline[1], outline[3]);
            var maxY = Math.Max(outline[1], outline[3]);
            if (string.Equals(symbol.CutLine.Direction, "horizontal", StringComparison.OrdinalIgnoreCase))
            {
                var sheetStart = new[] { minX, centerM[1] };
                var sheetEnd = new[] { maxX, centerM[1] };
                return BuildSectionSketchLineFromSheetPoints(
                    sheetStart,
                    sheetEnd,
                    center,
                    centerM,
                    parentX,
                    parentY,
                    symbol,
                    "cut_line_center_through_parent_view_outline_parent_local");
            }

            var verticalSheetStart = new[] { centerM[0], maxY };
            var verticalSheetEnd = new[] { centerM[0], minY };
            return BuildSectionSketchLineFromSheetPoints(
                verticalSheetStart,
                verticalSheetEnd,
                center,
                centerM,
                parentX,
                parentY,
                symbol,
                "cut_line_center_through_parent_view_outline_parent_local");
        }

        return BuildSectionSketchLineFromSheetPoints(
            [symbol.CutLine.Start[0] / 1000.0, symbol.CutLine.Start[1] / 1000.0],
            [symbol.CutLine.End[0] / 1000.0, symbol.CutLine.End[1] / 1000.0],
            center,
            centerM,
            parentX,
            parentY,
            symbol,
            "fallback_cut_line_start_end_parent_local");
    }

    private static SectionSketchLine BuildSectionSketchLineFromSheetPoints(
        double[] sheetStartM,
        double[] sheetEndM,
        List<double> centerMm,
        double[] centerM,
        double parentX,
        double parentY,
        SectionCutSymbol symbol,
        string source)
    {
        var oriented = OrientSectionSketchLineByDwgArrow(sheetStartM, sheetEndM, symbol);
        var start = oriented.StartM;
        var end = oriented.EndM;
        return new SectionSketchLine(
            [start[0] * 1000.0, start[1] * 1000.0],
            [end[0] * 1000.0, end[1] * 1000.0],
            centerMm,
            [start[0] - parentX, start[1] - parentY],
            [end[0] - parentX, end[1] - parentY],
            [centerM[0] - parentX, centerM[1] - parentY],
            oriented.Reversed ? $"{source}_reversed_to_match_dwg_arrow" : source);
    }

    private static (double[] StartM, double[] EndM, bool Reversed) OrientSectionSketchLineByDwgArrow(
        double[] startM,
        double[] endM,
        SectionCutSymbol symbol)
    {
        var arrow = Normalize2(symbol.AverageArrowDirection);
        if (arrow == null)
            return (startM, endM, false);

        var defaultDirection = ComputeSectionLineDefaultArrowDirection(startM, endM);
        if (defaultDirection == null)
            return (startM, endM, false);

        var dot = defaultDirection[0] * arrow[0] + defaultDirection[1] * arrow[1];
        return dot < 0
            ? (endM, startM, true)
            : (startM, endM, false);
    }

    private static double[]? ComputeSectionLineDefaultArrowDirection(double[] startM, double[] endM)
    {
        var dx = endM[0] - startM[0];
        var dy = endM[1] - startM[1];
        var length = Math.Sqrt(dx * dx + dy * dy);
        if (length <= 1e-9)
            return null;

        // SolidWorks follows the section line orientation; use the left normal
        // as the automatic direction and reverse the line when DWG arrows disagree.
        return [-dy / length, dx / length];
    }

    private static double[]? Normalize2(IReadOnlyList<double> vector)
    {
        if (vector.Count < 2)
            return null;
        var x = vector[0];
        var y = vector[1];
        var length = Math.Sqrt(x * x + y * y);
        return length <= 1e-9 ? null : [x / length, y / length];
    }

    private static double[] ComputeSectionViewPlacement(SectionCutSymbol symbol, double offsetM)
    {
        var center = symbol.CutLine.Center.Count >= 2
            ? symbol.CutLine.Center
            : [
                (symbol.CutLine.Start[0] + symbol.CutLine.End[0]) / 2.0,
                (symbol.CutLine.Start[1] + symbol.CutLine.End[1]) / 2.0
            ];
        var midX = center[0] / 1000.0;
        var midY = center[1] / 1000.0;
        var arrow = symbol.AverageArrowDirection;
        var ax = arrow.Count >= 2 ? arrow[0] : 0.0;
        var ay = arrow.Count >= 2 ? arrow[1] : 0.0;

        if (string.Equals(symbol.CutLine.Direction, "vertical", StringComparison.OrdinalIgnoreCase))
            return [midX + Math.Sign(ax == 0 ? 1.0 : ax) * offsetM, midY];
        if (string.Equals(symbol.CutLine.Direction, "horizontal", StringComparison.OrdinalIgnoreCase))
            return [midX, midY + Math.Sign(ay == 0 ? 1.0 : ay) * offsetM];

        var length = Math.Sqrt(ax * ax + ay * ay);
        if (length <= 1e-9)
            return [midX + offsetM, midY];
        return [midX + ax / length * offsetM, midY + ay / length * offsetM];
    }

    private static int BuildSectionViewOptions(SectionCutSymbol symbol, CandidateRequest request)
    {
        var options = (int)swCreateSectionViewAtOptions_e.swCreateSectionView_ScaleWithModel;
        if (request.SectionViewNotAligned)
            options |= (int)swCreateSectionViewAtOptions_e.swCreateSectionView_NotAligned;
        if (ShouldChangeSectionDirection(symbol, request))
            options |= (int)swCreateSectionViewAtOptions_e.swCreateSectionView_ChangeDirection;
        return options;
    }

    private static bool ShouldChangeSectionDirection(SectionCutSymbol symbol, CandidateRequest request)
    {
        if (request.SectionViewChangeDirection != null)
            return request.SectionViewChangeDirection.Value;

        return false;
    }

    private static List<SectionCutSymbol> ReadSectionCutSymbols(string path)
    {
        using var document = JsonDocument.Parse(File.ReadAllText(path));
        if (document.RootElement.ValueKind != JsonValueKind.Array)
            throw new InvalidOperationException($"Section cut symbols JSON root must be an array: {path}");

        var result = new List<SectionCutSymbol>();
        foreach (var element in document.RootElement.EnumerateArray())
        {
            var symbol = new SectionCutSymbol
            {
                Ok = ReadBool(element, "ok"),
                Kind = ReadString(element, "kind"),
                Label = ReadString(element, "label"),
                ParentHandle = ReadString(element, "parent_handle"),
                ViewKind = ReadString(element, "view_kind"),
                CutLine = ReadSectionCutLine(element)
            };
            symbol.AverageArrowDirection = ReadAverageArrowDirection(element);
            result.Add(symbol);
        }

        return result;
    }

    private static SectionCutLine ReadSectionCutLine(JsonElement element)
    {
        if (!element.TryGetProperty("cut_line", out var cutLine))
            throw new InvalidOperationException("Section cut symbol is missing cut_line.");
        return new SectionCutLine
        {
            Start = ReadPoint(cutLine, "start"),
            End = ReadPoint(cutLine, "end"),
            Center = ReadPoint(cutLine, "center"),
            Direction = ReadString(cutLine, "direction")
        };
    }

    private static List<double> ReadAverageArrowDirection(JsonElement element)
    {
        if (!element.TryGetProperty("markers", out var markers) || markers.ValueKind != JsonValueKind.Array)
            return [0.0, 0.0];

        var vectors = markers.EnumerateArray()
            .Where(marker => marker.TryGetProperty("arrow_direction", out var direction) && direction.ValueKind == JsonValueKind.Array)
            .Select(marker => ReadPoint(marker, "arrow_direction"))
            .Where(point => point.Count >= 2)
            .ToList();
        if (vectors.Count == 0)
            return [0.0, 0.0];

        return
        [
            vectors.Average(vector => vector[0]),
            vectors.Average(vector => vector[1])
        ];
    }

    private static bool ReadBool(JsonElement element, string propertyName)
    {
        return element.TryGetProperty(propertyName, out var value) &&
               value.ValueKind == JsonValueKind.True;
    }

    private static string ReadString(JsonElement element, string propertyName)
    {
        return element.TryGetProperty(propertyName, out var value) && value.ValueKind == JsonValueKind.String
            ? value.GetString() ?? ""
            : "";
    }

    private static List<double> ReadPoint(JsonElement element, string propertyName)
    {
        if (!element.TryGetProperty(propertyName, out var value) || value.ValueKind != JsonValueKind.Array)
            return [];
        return value.EnumerateArray()
            .Where(item => item.ValueKind == JsonValueKind.Number)
            .Select(item => item.GetDouble())
            .ToList();
    }

    private static (double X, double Y) ReadSignatureOrigin(string path, string label)
    {
        if (string.IsNullOrWhiteSpace(path))
            throw new ArgumentException($"缺少 {label} signature path。");
        if (!File.Exists(path))
            throw new FileNotFoundException($"{label} signature 不存在: {path}");

        using var document = JsonDocument.Parse(File.ReadAllText(path));
        if (!document.RootElement.TryGetProperty("relative_line_coordinates", out var relative) ||
            !relative.TryGetProperty("origin", out var origin) ||
            !origin.TryGetProperty("x", out var xElement) ||
            !origin.TryGetProperty("y", out var yElement))
            throw new InvalidOperationException($"{label} signature 缺少 relative_line_coordinates.origin: {path}");

        return (xElement.GetDouble(), yElement.GetDouble());
    }

    private static View? FindMainDrawingView(DrawingDoc drawing, CandidateRequest request)
    {
        var viewObj = drawing.GetFirstView();
        while (viewObj is View view)
        {
            var name = Safe(() => view.GetName2(), "");
            var orientationName = Safe(() => view.GetOrientationName(), "");
            if (!string.IsNullOrWhiteSpace(request.MainViewOrientationName))
            {
                if (string.Equals(orientationName, request.MainViewOrientationName, StringComparison.OrdinalIgnoreCase) ||
                    string.Equals(name, request.MainViewOrientationName, StringComparison.OrdinalIgnoreCase))
                    return view;
            }
            else if (LooksLikeCandidateView(name, orientationName, request.MainViewNamePrefix))
            {
                return view;
            }

            viewObj = view.GetNextView();
        }

        return null;
    }

    private static void CreateNamedViews(ModelDoc2 model, object mathUtility, List<ViewCandidate> candidates, bool keepNamedViews)
    {
        var activeView = model.IActiveView as ModelView ?? model.ActiveView as ModelView
            ?? throw new InvalidOperationException("模型没有可用 ActiveView，无法设置 Orientation3。");

        foreach (var candidate in candidates)
        {
            if (keepNamedViews)
                Safe(() => model.DeleteNamedView(candidate.Name), false);
            else
                Safe(() => model.DeleteNamedView(candidate.Name), false);

            var transformData = new double[]
            {
                candidate.BasisU[0], candidate.BasisU[1], candidate.BasisU[2],
                candidate.BasisV[0], candidate.BasisV[1], candidate.BasisV[2],
                candidate.BasisD[0], candidate.BasisD[1], candidate.BasisD[2],
                0.0, 0.0, 0.0,
                1.0,
                0.0, 0.0, 0.0
            };

            dynamic utility = mathUtility;
            MathTransform transform = utility.CreateTransform(transformData);
            activeView.Orientation3 = transform;
            model.GraphicsRedraw2();
            model.NameView(candidate.Name);
        }
    }

    private static void ExportCandidateDwgsSequential(
        ModelDoc2 drawingModel,
        DrawingDoc drawing,
        string modelPath,
        List<ViewCandidate> candidates,
        CandidateRequest request)
    {
        var dwgDir = CandidateDwgDirectory(request);
        Directory.CreateDirectory(dwgDir);

        foreach (var candidate in candidates)
        {
            var dwgPath = Path.Combine(dwgDir, $"{candidate.Index:00}_{SanitizeFileName(candidate.Name)}.dwg");
            ExportSingleCandidateDwgUntilSaved(drawingModel, drawing, modelPath, candidate, request, dwgPath);
        }

        if (!request.KeepExportedCandidateView)
            CleanupCandidateDrawingViews(drawingModel, drawing, request.ViewNamePrefix);
    }

    private static void ExportSingleCandidateDwgUntilSaved(
        ModelDoc2 drawingModel,
        DrawingDoc drawing,
        string modelPath,
        ViewCandidate candidate,
        CandidateRequest request,
        string dwgPath)
    {
        var rebuildAttempt = 0;
        var maxRebuildAttempts = Math.Max(0, request.CandidateRebuildRetryCount);

        while (maxRebuildAttempts == 0 || rebuildAttempt < maxRebuildAttempts)
        {
            rebuildAttempt++;
            candidate.DwgRebuildAttempts = rebuildAttempt;
            candidate.DwgPath = dwgPath;

            CleanupCandidateDrawingViews(drawingModel, drawing, request.ViewNamePrefix);
            var view = InsertSingleCandidateView(drawing, modelPath, candidate, request);
            if (view == null)
            {
                candidate.DwgSaveOk = false;
                candidate.DwgSaveErrors = -1;
                candidate.DwgSaveWarnings = 0;
                candidate.DwgSaveMessage = $"第 {rebuildAttempt} 轮重建失败：CreateDrawViewFromModelView3 返回空。";
                WaitBeforeNextCandidateAttempt(request);
                continue;
            }

            Safe(() => drawingModel.ForceRebuild3(false), false);
            WaitBeforeNextCandidateAttempt(request);

            var saveResult = SaveAsWithRetries(drawingModel, dwgPath, request.SaveRetryCount, request.SaveRetryDelayMs);
            candidate.DwgSaveOk = saveResult.Ok;
            candidate.DwgSaveErrors = saveResult.Errors;
            candidate.DwgSaveWarnings = saveResult.Warnings;

            if (saveResult.Ok)
            {
                candidate.DwgSaveMessage = $"第 {rebuildAttempt} 轮重建后保存成功。";
                if (!request.KeepExportedCandidateView)
                    DeleteDrawingView(drawingModel, candidate);
                return;
            }

            candidate.DwgSaveMessage = $"第 {rebuildAttempt} 轮重建后保存失败：errors={saveResult.Errors}, warnings={saveResult.Warnings}。";
            Console.Error.WriteLine(
                $"候选 {candidate.Index:00} 保存失败，准备重建后重试：attempt={rebuildAttempt}, errors={saveResult.Errors}, warnings={saveResult.Warnings}");

            if (!request.KeepExportedCandidateView)
                DeleteDrawingView(drawingModel, candidate);

            WaitBeforeNextCandidateAttempt(request);
        }

        candidate.DwgSaveOk = false;
        candidate.DwgSaveMessage = $"达到候选视图重建重试上限 {maxRebuildAttempts}，仍未保存成功。";
        throw new InvalidOperationException($"候选 {candidate.Index:00} DWG 保存失败，已达到重建重试上限 {maxRebuildAttempts}。");
    }

    private static void WaitBeforeNextCandidateAttempt(CandidateRequest request)
    {
        if (request.SaveRetryDelayMs > 0)
            Thread.Sleep(request.SaveRetryDelayMs);
    }

    private static View? InsertSingleCandidateView(DrawingDoc drawing, string modelPath, ViewCandidate candidate, CandidateRequest request)
    {
        var x = request.SingleViewXM ?? request.SheetWidthM / 2.0;
        var y = request.SingleViewYM ?? request.SheetHeightM / 2.0;
        var view = drawing.CreateDrawViewFromModelView3(modelPath, candidate.Name, x, y, 0);
        if (view == null)
        {
            candidate.Inserted = false;
            candidate.InsertError = "CreateDrawViewFromModelView3 returned null.";
            return null;
        }

        if (request.ViewScale > 0)
            Safe(() => { view.UseSheetScale = 0; view.ScaleDecimal = request.ViewScale; return true; }, false);

        candidate.Inserted = true;
        candidate.DrawingViewName = Safe(() => view.GetName2(), "");
        candidate.OrientationName = Safe(() => view.GetOrientationName(), "");
        candidate.Position = DoubleList(Safe(() => view.Position, null));
        candidate.ScaleDecimal = Safe(() => view.ScaleDecimal, 0.0);
        candidate.UseSheetScale = Safe(() => view.UseSheetScale, 0);
        return view;
    }

    private static string CandidateDwgDirectory(CandidateRequest request)
    {
        return string.IsNullOrWhiteSpace(request.CandidateDwgDir)
            ? Path.Combine(request.OutputDir, "candidate-dwgs")
            : request.CandidateDwgDir;
    }

    private static void CleanupCandidateDrawingViews(ModelDoc2 drawingModel, DrawingDoc drawing, string prefix)
    {
        var toDelete = new List<ViewCandidate>();
        var viewObj = drawing.GetFirstView();
        while (viewObj is View view)
        {
            var name = Safe(() => view.GetName2(), "");
            var orientationName = Safe(() => view.GetOrientationName(), "");
            if (LooksLikeCandidateView(name, orientationName, prefix))
            {
                toDelete.Add(new ViewCandidate
                {
                    DrawingViewName = name,
                    OrientationName = orientationName
                });
            }
            viewObj = view.GetNextView();
        }

        foreach (var candidate in toDelete)
            DeleteDrawingView(drawingModel, candidate);
    }

    private static bool LooksLikeCandidateView(string viewName, string orientationName, string prefix)
    {
        return (!string.IsNullOrWhiteSpace(orientationName) && orientationName.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) ||
               (!string.IsNullOrWhiteSpace(viewName) && viewName.StartsWith(prefix, StringComparison.OrdinalIgnoreCase));
    }

    private static bool DeleteDrawingView(ModelDoc2 drawingModel, ViewCandidate candidate)
    {
        var names = new[]
        {
            candidate.DrawingViewName,
            candidate.OrientationName,
            candidate.Name
        };

        foreach (var name in names.Where(item => !string.IsNullOrWhiteSpace(item)).Distinct(StringComparer.OrdinalIgnoreCase))
        {
            drawingModel.ClearSelection2(true);
            var selected = Safe(() => drawingModel.Extension.SelectByID2(name, "DRAWINGVIEW", 0, 0, 0, false, 0, null, 0), false);
            if (!selected)
                continue;
            var deleted = Safe(() => drawingModel.Extension.DeleteSelection2(0), false);
            drawingModel.ClearSelection2(true);
            if (deleted)
                return true;
        }

        return false;
    }

    private static SaveResult SaveAs(ModelDoc2 model, string path)
    {
        var errors = 0;
        var warnings = 0;
        Directory.CreateDirectory(Path.GetDirectoryName(path) ?? System.Environment.CurrentDirectory);
        var ok = Safe(() => model.SaveAs4(
            path,
            (int)swSaveAsVersion_e.swSaveAsCurrentVersion,
            (int)swSaveAsOptions_e.swSaveAsOptions_Silent,
            ref errors,
            ref warnings), false);
        if (!ok && !File.Exists(path))
        {
            errors = 0;
            warnings = 0;
            ok = model.Extension.SaveAs(
                path,
                (int)swSaveAsVersion_e.swSaveAsCurrentVersion,
                (int)swSaveAsOptions_e.swSaveAsOptions_Silent,
                null,
                ref errors,
                ref warnings);
        }
        return new SaveResult(ok || File.Exists(path), errors, warnings);
    }

    private static SaveResult SaveAsWithRetries(ModelDoc2 model, string path, int retryCount, int retryDelayMs)
    {
        retryCount = Math.Max(1, retryCount);
        retryDelayMs = Math.Max(0, retryDelayMs);
        var last = new SaveResult(false, 0, 0);
        for (var attempt = 1; attempt <= retryCount; attempt++)
        {
            Safe(() => model.ForceRebuild3(false), false);
            if (attempt > 1 && retryDelayMs > 0)
                Thread.Sleep(retryDelayMs);

            last = SaveAs(model, path);
            if (last.Ok)
                return last;
        }
        return last;
    }

    private static void DeleteNamedViews(ModelDoc2 model, List<ViewCandidate> candidates)
    {
        foreach (var candidate in candidates)
            Safe(() => model.DeleteNamedView(candidate.Name), false);
    }

    private static (double[] U, double[] V, double[] D) BuildBasis(double[] direction, double rollDeg)
    {
        var d = Normalize(direction);
        var worldUp = Math.Abs(Dot(d, [0.0, 1.0, 0.0])) > 0.92
            ? new[] { 0.0, 0.0, 1.0 }
            : new[] { 0.0, 1.0, 0.0 };
        var u = Normalize(Cross(worldUp, d));
        var v = Normalize(Cross(d, u));

        var rad = rollDeg * Math.PI / 180.0;
        var cos = Math.Cos(rad);
        var sin = Math.Sin(rad);
        var rolledU = Add(Scale(u, cos), Scale(v, sin));
        var rolledV = Add(Scale(u, -sin), Scale(v, cos));
        return (Normalize(rolledU), Normalize(rolledV), d);
    }

    private static double[] Normalize(double[] v)
    {
        var norm = Math.Sqrt(Dot(v, v));
        if (norm <= 1e-12)
            return [0, 0, 1];
        return [v[0] / norm, v[1] / norm, v[2] / norm];
    }

    private static double Dot(double[] a, double[] b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];

    private static double[] Cross(double[] a, double[] b)
    {
        return
        [
            a[1] * b[2] - a[2] * b[1],
            a[2] * b[0] - a[0] * b[2],
            a[0] * b[1] - a[1] * b[0]
        ];
    }

    private static double[] Add(double[] a, double[] b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];

    private static double[] Scale(double[] a, double k) => [a[0] * k, a[1] * k, a[2] * k];

    private static List<double> DoubleList(object? value)
    {
        if (value == null)
            return [];
        if (value is double[] doubles)
            return doubles.ToList();
        if (value is object[] objects)
            return objects.SelectMany(DoubleList).ToList();
        if (value is Array array)
        {
            var result = new List<double>();
            foreach (var item in array)
            {
                if (item == null)
                    continue;
                if (double.TryParse(Convert.ToString(item, CultureInfo.InvariantCulture), NumberStyles.Float, CultureInfo.InvariantCulture, out var parsed))
                    result.Add(parsed);
            }
            return result;
        }
        return [];
    }

    private static string NormalizePath(string? path)
    {
        if (string.IsNullOrWhiteSpace(path))
            return "";
        return Path.GetFullPath(System.Environment.ExpandEnvironmentVariables(path.Trim().Trim('"')));
    }

    private static string SanitizeFileName(string name)
    {
        var value = Path.GetFileNameWithoutExtension(name);
        if (string.IsNullOrWhiteSpace(value))
            value = "solidworks_view_candidates";
        foreach (var c in Path.GetInvalidFileNameChars())
            value = value.Replace(c, '_');
        return value;
    }

    private static string FirstNonEmpty(params string?[] values)
    {
        foreach (var value in values)
        {
            if (!string.IsNullOrWhiteSpace(value))
                return value.Trim();
        }
        return "";
    }

    private static void WriteJson(string path, object data)
    {
        Directory.CreateDirectory(Path.GetDirectoryName(path) ?? System.Environment.CurrentDirectory);
        File.WriteAllText(path, JsonSerializer.Serialize(data, JsonOptions));
    }

    private static T Safe<T>(Func<T> action, T fallback)
    {
        try { return action(); }
        catch { return fallback; }
    }
}

internal sealed class CandidateRequest
{
    public string ModelPath { get; set; } = "";
    public string DrawingTemplatePath { get; set; } = "";
    public string OutputDir { get; set; } = "";
    public string CandidateDwgDir { get; set; } = "";
    public string RankingJsonPath { get; set; } = "";
    public string StudentSignaturePath { get; set; } = "";
    public string ReferenceSignaturePath { get; set; } = "";
    public string StudentViewRegionsPath { get; set; } = "";
    public string ReferenceViewRegionsPath { get; set; } = "";
    public string OutputDwgPath { get; set; } = "";
    public string SectionCutSymbolsPath { get; set; } = "";
    public string ViewNamePrefix { get; set; } = "agent4_candidate";
    public string MainViewNamePrefix { get; set; } = "agent4_main_view";
    public string MainViewOrientationName { get; set; } = "";
    public string AlignmentAxis { get; set; } = "xy";
    public string ProjectedViewName { get; set; } = "agent4_bottom_projected_view";
    public string ProjectedViewDirection { get; set; } = "down";
    public string SectionLabel { get; set; } = "";
    public string SectionViewNamePrefix { get; set; } = "agent4_section_view";
    public double SheetWidthM { get; set; } = 0.594;
    public double SheetHeightM { get; set; } = 0.420;
    public int? CandidateIndex { get; set; }
    public double ViewScale { get; set; } = 1.0;
    public double? SingleViewXM { get; set; }
    public double? SingleViewYM { get; set; }
    public double? ProjectedViewXM { get; set; }
    public double? ProjectedViewYM { get; set; }
    public double SectionViewOffsetM { get; set; } = 0.18;
    public double SectionDepthM { get; set; } = 0.0;
    public int SaveRetryCount { get; set; } = 3;
    public int SaveRetryDelayMs { get; set; } = 1000;
    public int CandidateRebuildRetryCount { get; set; } = 0;
    public bool KeepNamedViews { get; set; }
    public bool UseActiveDrawing { get; set; }
    public bool UseActiveModel { get; set; }
    public bool ExportCandidateDwgsSequential { get; set; }
    public bool ExportActiveDrawingDwg { get; set; }
    public bool ListDrawingViews { get; set; }
    public bool KeepExportedCandidateView { get; set; }
    public bool PlaceMainView { get; set; }
    public bool PlaceProjectedView { get; set; }
    public bool PlaceSectionViews { get; set; }
    public bool AlignMainViewOrigin { get; set; }
    public bool AlignProjectedViewsToRegions { get; set; }
    public bool AlignSectionViewsToRegions { get; set; }
    public bool ReplaceExistingMainView { get; set; } = true;
    public bool ReplaceExistingProjectedView { get; set; } = true;
    public bool ReplaceExistingSectionViews { get; set; } = true;
    public bool SectionViewNotAligned { get; set; }
    public bool? SectionViewChangeDirection { get; set; }

    public static CandidateRequest Parse(string[] args)
    {
        var request = new CandidateRequest();
        for (var i = 0; i < args.Length; i++)
        {
            var arg = args[i];
            string Next() => i + 1 < args.Length ? args[++i] : throw new ArgumentException($"缺少参数值: {arg}");
            switch (arg)
            {
                case "--request-json":
                    request = JsonSerializer.Deserialize<CandidateRequest>(File.ReadAllText(Next()), new JsonSerializerOptions { PropertyNameCaseInsensitive = true })
                        ?? new CandidateRequest();
                    break;
                case "--model":
                    request.ModelPath = Next();
                    break;
                case "--template":
                    request.DrawingTemplatePath = Next();
                    break;
                case "--output-dir":
                    request.OutputDir = Next();
                    break;
                case "--candidate-dwg-dir":
                    request.CandidateDwgDir = Next();
                    break;
                case "--ranking-json":
                    request.RankingJsonPath = Next();
                    break;
                case "--student-signature":
                    request.StudentSignaturePath = Next();
                    break;
                case "--reference-signature":
                    request.ReferenceSignaturePath = Next();
                    break;
                case "--student-view-regions":
                    request.StudentViewRegionsPath = Next();
                    break;
                case "--reference-view-regions":
                    request.ReferenceViewRegionsPath = Next();
                    break;
                case "--dwg":
                    request.OutputDwgPath = Next();
                    break;
                case "--section-cut-symbols":
                    request.SectionCutSymbolsPath = Next();
                    break;
                case "--view-name-prefix":
                    request.ViewNamePrefix = Next();
                    break;
                case "--main-view-name-prefix":
                    request.MainViewNamePrefix = Next();
                    break;
                case "--main-view-orientation-name":
                    request.MainViewOrientationName = Next();
                    break;
                case "--alignment-axis":
                    request.AlignmentAxis = Next();
                    break;
                case "--projected-view-name":
                    request.ProjectedViewName = Next();
                    break;
                case "--projected-view-direction":
                    request.ProjectedViewDirection = Next();
                    break;
                case "--section-label":
                    request.SectionLabel = Next();
                    break;
                case "--section-view-name-prefix":
                    request.SectionViewNamePrefix = Next();
                    break;
                case "--sheet-width-m":
                    request.SheetWidthM = double.Parse(Next(), CultureInfo.InvariantCulture);
                    break;
                case "--sheet-height-m":
                    request.SheetHeightM = double.Parse(Next(), CultureInfo.InvariantCulture);
                    break;
                case "--candidate-index":
                    request.CandidateIndex = int.Parse(Next(), CultureInfo.InvariantCulture);
                    break;
                case "--view-scale":
                    request.ViewScale = double.Parse(Next(), CultureInfo.InvariantCulture);
                    break;
                case "--single-view-x-m":
                    request.SingleViewXM = double.Parse(Next(), CultureInfo.InvariantCulture);
                    break;
                case "--single-view-y-m":
                    request.SingleViewYM = double.Parse(Next(), CultureInfo.InvariantCulture);
                    break;
                case "--projected-view-x-m":
                    request.ProjectedViewXM = double.Parse(Next(), CultureInfo.InvariantCulture);
                    break;
                case "--projected-view-y-m":
                    request.ProjectedViewYM = double.Parse(Next(), CultureInfo.InvariantCulture);
                    break;
                case "--section-view-offset-m":
                    request.SectionViewOffsetM = double.Parse(Next(), CultureInfo.InvariantCulture);
                    break;
                case "--section-depth-m":
                    request.SectionDepthM = double.Parse(Next(), CultureInfo.InvariantCulture);
                    break;
                case "--save-retry-count":
                    request.SaveRetryCount = int.Parse(Next(), CultureInfo.InvariantCulture);
                    break;
                case "--save-retry-delay-ms":
                    request.SaveRetryDelayMs = int.Parse(Next(), CultureInfo.InvariantCulture);
                    break;
                case "--candidate-rebuild-retry-count":
                    request.CandidateRebuildRetryCount = int.Parse(Next(), CultureInfo.InvariantCulture);
                    break;
                case "--keep-named-views":
                    request.KeepNamedViews = true;
                    break;
                case "--use-active-drawing":
                    request.UseActiveDrawing = true;
                    break;
                case "--use-active-model":
                    request.UseActiveModel = true;
                    break;
                case "--export-candidate-dwgs-sequential":
                    request.ExportCandidateDwgsSequential = true;
                    break;
                case "--export-active-drawing-dwg":
                    request.ExportActiveDrawingDwg = true;
                    break;
                case "--list-drawing-views":
                    request.ListDrawingViews = true;
                    break;
                case "--keep-exported-candidate-view":
                    request.KeepExportedCandidateView = true;
                    break;
                case "--place-main-view":
                    request.PlaceMainView = true;
                    break;
                case "--place-projected-view":
                    request.PlaceProjectedView = true;
                    break;
                case "--place-section-views":
                    request.PlaceSectionViews = true;
                    break;
                case "--align-main-view-origin":
                    request.AlignMainViewOrigin = true;
                    break;
                case "--align-projected-views-to-regions":
                case "--align-orthographic-views-to-regions":
                    request.AlignProjectedViewsToRegions = true;
                    break;
                case "--align-section-views-to-regions":
                    request.AlignSectionViewsToRegions = true;
                    break;
                case "--keep-existing-main-view":
                    request.ReplaceExistingMainView = false;
                    break;
                case "--keep-existing-projected-view":
                    request.ReplaceExistingProjectedView = false;
                    break;
                case "--keep-existing-section-views":
                    request.ReplaceExistingSectionViews = false;
                    break;
                case "--section-view-not-aligned":
                    request.SectionViewNotAligned = true;
                    break;
                case "--section-view-change-direction":
                    request.SectionViewChangeDirection = true;
                    break;
                case "--section-view-keep-direction":
                    request.SectionViewChangeDirection = false;
                    break;
                default:
                    throw new ArgumentException($"未知参数: {arg}");
            }
        }
        return request;
    }
}

internal sealed class CandidateResult
{
    public bool Ok { get; set; }
    public string Message { get; set; } = "";
    public string ModelPath { get; set; } = "";
    public string DrawingTemplatePath { get; set; } = "";
    public string DrawingPath { get; set; } = "";
    public bool UsedActiveDrawing { get; set; }
    public string OutputDir { get; set; } = "";
    public DateTimeOffset StartedAt { get; set; }
    public DateTimeOffset CompletedAt { get; set; }
    public List<ViewCandidate> Candidates { get; set; } = [];
    public Dictionary<string, string> Artifacts { get; set; } = new(StringComparer.OrdinalIgnoreCase);
    public List<string> SourceApis { get; set; } = [];
}

internal sealed class ViewCandidate
{
    public int Index { get; set; }
    public string Name { get; set; } = "";
    public string DirectionName { get; set; } = "";
    public int RollDeg { get; set; }
    public List<double> ViewDirection { get; set; } = [];
    public List<double> BasisU { get; set; } = [];
    public List<double> BasisV { get; set; } = [];
    public List<double> BasisD { get; set; } = [];
    public bool Inserted { get; set; }
    public string InsertError { get; set; } = "";
    public string DrawingViewName { get; set; } = "";
    public string OrientationName { get; set; } = "";
    public List<double> Position { get; set; } = [];
    public double ScaleDecimal { get; set; }
    public int UseSheetScale { get; set; }
    public string DwgPath { get; set; } = "";
    public bool DwgSaveOk { get; set; }
    public int DwgSaveErrors { get; set; }
    public int DwgSaveWarnings { get; set; }
    public int DwgRebuildAttempts { get; set; }
    public string DwgSaveMessage { get; set; } = "";
}

internal sealed record DrawingContext(ModelDoc2 Model, DrawingDoc Drawing, string TemplatePath, string DrawingPath);

internal sealed record SaveResult(bool Ok, int Errors, int Warnings);

internal sealed class SectionCutSymbol
{
    public bool Ok { get; set; }
    public string Kind { get; set; } = "";
    public string Label { get; set; } = "";
    public string ParentHandle { get; set; } = "";
    public string ViewKind { get; set; } = "";
    public SectionCutLine CutLine { get; set; } = new();
    public List<double> AverageArrowDirection { get; set; } = [];
}

internal sealed class SectionCutLine
{
    public List<double> Start { get; set; } = [];
    public List<double> End { get; set; } = [];
    public List<double> Center { get; set; } = [];
    public string Direction { get; set; } = "";
}

internal sealed record SectionRegionCenter(string Label, double CenterX, double CenterY);

internal sealed record OrthographicRegionCenter(string Kind, double CenterX, double CenterY);

internal sealed record SectionRegionDelta(double DeltaMmX, double DeltaMmY, double AppliedDeltaMmX, double AppliedDeltaMmY);

internal sealed record SectionSketchLine(
    List<double> StartMm,
    List<double> EndMm,
    List<double> CenterMm,
    double[] StartM,
    double[] EndM,
    double[] CenterM,
    string Source);