ViewDesignEngine/tests/brep/test_tolerant_modeling.cpp

#include <gtest/gtest.h>
#include "vde/brep/brep.h"
#include "vde/brep/modeling.h"
#include "vde/brep/brep_validate.h"
#include "vde/brep/brep_heal.h"
#include "vde/brep/tolerant_modeling.h"
#include "vde/brep/tolerance.h"
#include "vde/brep/ssi_boolean.h"
#include "vde/brep/step_import.h"
#include "vde/curves/nurbs_surface.h"
#include "vde/core/point.h"

using namespace vde::brep;
using namespace vde::core;
using namespace vde::curves;

namespace {

/// Create a simple planar NURBS surface on the XY plane
NurbsSurface make_plane_surface() {
    std::vector<std::vector<Point3D>> grid = {
        {Point3D(-1, -1, 0), Point3D(-1, 1, 0)},
        {Point3D( 1, -1, 0), Point3D( 1, 1, 0)}
    };
    return NurbsSurface(grid, {0,0,1,1}, {0,0,1,1}, {}, 1, 1);
}

/// Create a simple triangular BrepModel
BrepModel make_triangle(const Point3D& a, const Point3D& b, const Point3D& c) {
    BrepModel body;
    int v0 = body.add_vertex(a);
    int v1 = body.add_vertex(b);
    int v2 = body.add_vertex(c);
    int e0 = body.add_edge(v0, v1);
    int e1 = body.add_edge(v1, v2);
    int e2 = body.add_edge(v2, v0);
    int loop_id = body.add_loop({e0, e1, e2});
    auto surf = make_plane_surface();
    int sid = body.add_surface(surf);
    int fid = body.add_face(sid, {loop_id});
    int shell = body.add_shell({fid}, false);
    body.add_body({shell}, "triangle");
    return body;
}

/// Create a simple box using modeling API
BrepModel make_test_box() {
    return make_box(2.0, 2.0, 2.0);
}

} // namespace

// ═══════════════════════════════════════════════════════════
//  1. TolerantVertex / TolerantEdge 基本构造
// ═══════════════════════════════════════════════════════════

TEST(TolerantModelingTest, TolerantVertex_DefaultConstruction) {
    TolerantVertex tv;
    tv.id = 0;
    tv.point = Point3D(1, 2, 3);
    tv.tolerance = 1e-5;

    EXPECT_EQ(tv.id, 0);
    EXPECT_DOUBLE_EQ(tv.point.x(), 1.0);
    EXPECT_DOUBLE_EQ(tv.point.y(), 2.0);
    EXPECT_DOUBLE_EQ(tv.point.z(), 3.0);
    EXPECT_DOUBLE_EQ(tv.tolerance, 1e-5);
    EXPECT_EQ(tv.merged_from, 1);
    EXPECT_FALSE(tv.is_degenerate);
}

TEST(TolerantModelingTest, TolerantVertex_FromTopo) {
    TopoVertex topo;
    topo.id = 5;
    topo.point = Point3D(10, 20, 30);
    topo.tolerance = 1e-7;

    TolerantVertex tv = TolerantVertex::from_topo(topo);
    EXPECT_EQ(tv.id, 5);
    EXPECT_DOUBLE_EQ(tv.point.x(), 10.0);
    EXPECT_DOUBLE_EQ(tv.tolerance, 1e-7);
}

TEST(TolerantModelingTest, TolerantEdge_DefaultConstruction) {
    TolerantEdge te;
    te.id = 3;
    te.v_start = 1;
    te.v_end = 2;
    te.tolerance = 1e-6;
    te.is_tangent_contact = true;

    EXPECT_EQ(te.id, 3);
    EXPECT_EQ(te.v_start, 1);
    EXPECT_EQ(te.v_end, 2);
    EXPECT_FALSE(te.is_degenerate);
    EXPECT_FALSE(te.gap_flag);
    EXPECT_TRUE(te.is_tangent_contact);
}

TEST(TolerantModelingTest, TolerantEdge_FromTopo) {
    TopoEdge topo;
    topo.id = 7;
    topo.v_start = 0;
    topo.v_end = 1;

    TolerantEdge te = TolerantEdge::from_topo(topo);
    EXPECT_EQ(te.id, 7);
    EXPECT_EQ(te.v_start, 0);
    EXPECT_EQ(te.v_end, 1);
}

TEST(TolerantModelingTest, TolerantEdge_CheckDegenerate_True) {
    BrepModel body;
    int v0 = body.add_vertex(Point3D(0, 0, 0));
    int v1 = body.add_vertex(Point3D(1e-8, 1e-8, 0)); // extremely short edge
    int e0 = body.add_edge(v0, v1);

    TolerantEdge te = TolerantEdge::from_topo(body.edge(e0));
    te.tolerance = 1e-6;

    EXPECT_TRUE(te.check_degenerate(body));
}

TEST(TolerantModelingTest, TolerantEdge_CheckDegenerate_False) {
    BrepModel body;
    int v0 = body.add_vertex(Point3D(0, 0, 0));
    int v1 = body.add_vertex(Point3D(1, 0, 0));
    int e0 = body.add_edge(v0, v1);

    TolerantEdge te = TolerantEdge::from_topo(body.edge(e0));
    te.tolerance = 1e-6;

    EXPECT_FALSE(te.check_degenerate(body));
}

// ═══════════════════════════════════════════════════════════
//  2. build_tolerant_vertices / build_tolerant_edges
// ═══════════════════════════════════════════════════════════

TEST(TolerantModelingTest, BuildTolerantVertices) {
    BrepModel body;
    body.add_vertex(Point3D(0, 0, 0));
    body.add_vertex(Point3D(1, 0, 0));
    body.add_vertex(Point3D(0, 1, 0));

    auto tvs = build_tolerant_vertices(body, 1e-5);
    EXPECT_EQ(tvs.size(), 3u);
    for (const auto& tv : tvs) {
        EXPECT_DOUBLE_EQ(tv.tolerance, 1e-5);
        EXPECT_EQ(tv.merged_from, 1);
    }
}

TEST(TolerantModelingTest, BuildTolerantEdges) {
    BrepModel body;
    int v0 = body.add_vertex(Point3D(0, 0, 0));
    int v1 = body.add_vertex(Point3D(1, 0, 0));
    int v2 = body.add_vertex(Point3D(0, 1, 0));
    body.add_edge(v0, v1);
    body.add_edge(v1, v2);
    body.add_edge(v2, v0);

    auto tes = build_tolerant_edges(body);
    EXPECT_EQ(tes.size(), 3u);
    EXPECT_FALSE(tes[0].is_degenerate); // 1.0 length
}

// ═══════════════════════════════════════════════════════════
//  3. merge_within_tolerance
// ═══════════════════════════════════════════════════════════

TEST(TolerantModelingTest, MergeWithinTolerance_NearCoincident) {
    BrepModel body;
    int v0 = body.add_vertex(Point3D(0, 0, 0));
    int v1 = body.add_vertex(Point3D(1, 0, 0));
    int v2 = body.add_vertex(Point3D(0, 1, 0));
    int v_near = body.add_vertex(Point3D(1e-7, 1e-7, 1e-7));

    int e0 = body.add_edge(v0, v1);
    int e1 = body.add_edge(v1, v2);
    int e2 = body.add_edge(v2, v_near);

    int loop_id = body.add_loop({e0, e1, e2});
    auto surf = make_plane_surface();
    int sid = body.add_surface(surf);
    body.add_face(sid, {loop_id});

    size_t before = body.num_vertices();
    int merged = merge_within_tolerance(body, 1e-5);

    EXPECT_GE(merged, 1);
    EXPECT_LT(body.num_vertices(), before);
}

TEST(TolerantModelingTest, MergeWithinTolerance_Empty) {
    BrepModel body;
    EXPECT_EQ(merge_within_tolerance(body), 0);
}

TEST(TolerantModelingTest, MergeWithinTolerance_SingleVertex) {
    BrepModel body;
    body.add_vertex(Point3D(0, 0, 0));
    EXPECT_EQ(merge_within_tolerance(body), 0);
}

// ═══════════════════════════════════════════════════════════
//  4. gap_bridging
// ═══════════════════════════════════════════════════════════

TEST(TolerantModelingTest, GapBridging_Empty) {
    BrepModel body;
    EXPECT_EQ(gap_bridging(body), 0);
}

TEST(TolerantModelingTest, GapBridging_SingleTriangle_NoGaps) {
    auto body = make_triangle(Point3D(0,0,0), Point3D(1,0,0), Point3D(0,1,0));
    // A closed triangle has no free edges
    int bridged = gap_bridging(body, 1e-4);
    EXPECT_GE(bridged, 0);
}

// ═══════════════════════════════════════════════════════════
//  5. overlap_resolution
// ═══════════════════════════════════════════════════════════

TEST(TolerantModelingTest, OverlapResolution_Empty) {
    BrepModel body;
    EXPECT_EQ(overlap_resolution(body), 0);
}

TEST(TolerantModelingTest, OverlapResolution_SingleFace) {
    auto body = make_triangle(Point3D(0,0,0), Point3D(1,0,0), Point3D(0,1,0));
    EXPECT_EQ(overlap_resolution(body), 0);
}

// ═══════════════════════════════════════════════════════════
//  6. tolerant_boolean
// ═══════════════════════════════════════════════════════════

TEST(TolerantModelingTest, TolerantBoolean_EmptyBodies) {
    BrepModel a, b;
    auto diag = tolerant_boolean(a, b, 0); // union
    EXPECT_TRUE(diag.success);
    EXPECT_EQ(diag.result.num_faces(), 0u);
}

TEST(TolerantModelingTest, TolerantBoolean_UnionOfDisjoint) {
    auto box1 = make_box(1, 1, 1);
    auto box2 = make_box(1, 1, 1);

    auto diag = tolerant_boolean(box1, box2, 0); // union
    // May succeed or have failures — check that diagnostic is populated
    EXPECT_FALSE(diag.report().empty());
}

TEST(TolerantModelingTest, TolerantBoolean_InvalidOp) {
    auto box1 = make_box(1, 1, 1);
    auto box2 = make_box(1, 1, 1);

    auto diag = tolerant_boolean(box1, box2, 99);
    EXPECT_FALSE(diag.success);
    EXPECT_FALSE(diag.error_message.empty());
}

// ═══════════════════════════════════════════════════════════
//  7. BooleanDiagnostic
// ═══════════════════════════════════════════════════════════

TEST(TolerantModelingTest, BooleanDiagnostic_Default) {
    BooleanDiagnostic diag;
    EXPECT_FALSE(diag.success);
    EXPECT_FALSE(diag.has_failures());
    EXPECT_FALSE(diag.report().empty());
}

TEST(TolerantModelingTest, BooleanDiagnostic_HasFailures) {
    BooleanDiagnostic diag;
    EXPECT_FALSE(diag.has_failures());

    FailedFaceInfo ffi;
    ffi.face_id = 3;
    ffi.reason = "Test failure";
    diag.failed_faces.push_back(ffi);

    EXPECT_TRUE(diag.has_failures());
}

TEST(TolerantModelingTest, BooleanDiagnostic_FailedFaceInfo) {
    FailedFaceInfo ffi;
    ffi.face_id = 42;
    ffi.reason = "Coplanar degeneracy";
    ffi.related_face_id = 17;
    ffi.is_coplanar = true;
    ffi.suggested_tolerance = 1e-3;

    EXPECT_EQ(ffi.face_id, 42);
    EXPECT_EQ(ffi.related_face_id, 17);
    EXPECT_TRUE(ffi.is_coplanar);
    EXPECT_DOUBLE_EQ(ffi.suggested_tolerance, 1e-3);
}

// ═══════════════════════════════════════════════════════════
//  8. detect_coplanar_faces / detect_tangent_contact / detect_degenerate_edge
// ═══════════════════════════════════════════════════════════

TEST(TolerantModelingTest, DetectCoplanarFaces_SameBody) {
    auto body = make_triangle(Point3D(0,0,0), Point3D(1,0,0), Point3D(0,1,0));
    // Single face body → cannot check pair
    EXPECT_FALSE(detect_coplanar_faces(body, 0, 0));
}

TEST(TolerantModelingTest, DetectDegenerateEdge_Valid) {
    BrepModel body;
    int v0 = body.add_vertex(Point3D(0, 0, 0));
    int v1 = body.add_vertex(Point3D(1, 0, 0));
    int e0 = body.add_edge(v0, v1);

    EXPECT_FALSE(detect_degenerate_edge(body, e0));
}

TEST(TolerantModelingTest, DetectDegenerateEdge_Degenerate) {
    BrepModel body;
    int v0 = body.add_vertex(Point3D(0, 0, 0));
    int v1 = body.add_vertex(Point3D(1e-8, 0, 0));
    int e0 = body.add_edge(v0, v1);

    EXPECT_TRUE(detect_degenerate_edge(body, e0, 1e-5));
}

// ═══════════════════════════════════════════════════════════
//  9. import_heal_pipeline
// ═══════════════════════════════════════════════════════════

TEST(TolerantModelingTest, ImportHealPipeline_Empty) {
    auto bodies = import_heal_pipeline("");
    EXPECT_TRUE(bodies.empty());
}

TEST(TolerantModelingTest, ImportHealPipeline_InvalidStep) {
    auto bodies = import_heal_pipeline("garbage data");
    EXPECT_TRUE(bodies.empty());
}

TEST(TolerantModelingTest, ImportHealPipeline_ValidStepData) {
    // 测试最小合法 STEP 数据
    std::string step_data = R"(
ISO-10303-21;
HEADER;
FILE_DESCRIPTION(('Test'),'2;1');
FILE_SCHEMA(('CONFIG_CONTROL_DESIGN'));
ENDSEC;
DATA;
#1=CARTESIAN_POINT('',(0.,0.,0.));
#2=CARTESIAN_POINT('',(1.,0.,0.));
#3=CARTESIAN_POINT('',(1.,1.,0.));
#4=CARTESIAN_POINT('',(0.,1.,0.));
ENDSEC;
END-ISO-10303-21;
)";
    auto bodies = import_heal_pipeline(step_data);
    // 此数据没有完整拓扑结构，预期为空或部分结果
    // 主要验证不崩溃
    EXPECT_TRUE(bodies.empty() || !bodies.empty());
}

// ═══════════════════════════════════════════════════════════
//  10. STEP import diagnostic
// ═══════════════════════════════════════════════════════════

TEST(TolerantModelingTest, StepImportDiagnostic_AfterImport) {
    std::string step_data = R"(
ISO-10303-21;
HEADER;
FILE_DESCRIPTION(('Test'),'2;1');
FILE_SCHEMA(('CONFIG_CONTROL_DESIGN'));
ENDSEC;
DATA;
#1=CARTESIAN_POINT('',(0.,0.,0.));
ENDSEC;
END-ISO-10303-21;
)";
    import_step_from_string(step_data);
    auto report = step_import_diagnostic();
    // 应至少解析到 1 个实体
    EXPECT_GE(report.total_entities, 1);
}

TEST(TolerantModelingTest, StepImportDiagnostic_ReportFormat) {
    std::string step_data = R"(
ISO-10303-21;
HEADER;
FILE_DESCRIPTION(('Test'),'2;1');
FILE_SCHEMA(('CONFIG_CONTROL_DESIGN'));
ENDSEC;
DATA;
ENDSEC;
END-ISO-10303-21;
)";
    import_step_from_string(step_data);
    auto report = step_import_diagnostic();
    auto str = report.report();
    EXPECT_FALSE(str.empty());
    EXPECT_TRUE(str.find("STEP Import Diagnostic") != std::string::npos);
}

// ═══════════════════════════════════════════════════════════
//  11. Damaged STEP recovery
// ═══════════════════════════════════════════════════════════

TEST(TolerantModelingTest, StepImport_DamagedEntityRecovery) {
    // 包含损坏实体的 STEP 数据：不完整的实体定义
    std::string step_data = R"(
ISO-10303-21;
HEADER;
FILE_DESCRIPTION(('Damaged'),'2;1');
FILE_SCHEMA(('CONFIG_CONTROL_DESIGN'));
ENDSEC;
DATA;
#10=INCOMPLETE_ENTITY
#1=CARTESIAN_POINT('',(0.,0.,0.));
#2=CARTESIAN_POINT('',(1.,0.,0.));
ENDSEC;
END-ISO-10303-21;
)";
    auto bodies = import_step_from_string(step_data);
    // 即使有损坏实体，仍应能解析 CARTESIAN_POINT
    auto report = step_import_diagnostic();
    EXPECT_GE(report.skipped_damaged, 1);
}

// ═══════════════════════════════════════════════════════════
//  12. TolerantEdge 管状边新功能
// ═══════════════════════════════════════════════════════════

TEST(TolerantModelingTest, TolerantEdge_TubeRadius_CacheFromBody) {
    BrepModel body;
    int v0 = body.add_vertex(Point3D(0, 0, 0));
    int v1 = body.add_vertex(Point3D(3, 4, 0));
    body.add_edge(v0, v1);

    auto tes = build_tolerant_edges(body, 1e-6);
    ASSERT_EQ(tes.size(), 1u);

    const auto& te = tes[0];
    EXPECT_DOUBLE_EQ(te.p_start.x(), 0.0);
    EXPECT_DOUBLE_EQ(te.p_start.y(), 0.0);
    EXPECT_DOUBLE_EQ(te.p_end.x(), 3.0);
    EXPECT_DOUBLE_EQ(te.p_end.y(), 4.0);
    EXPECT_DOUBLE_EQ(te.length(), 5.0);
    EXPECT_GE(te.tube_radius, 1e-6);
}

TEST(TolerantModelingTest, TolerantEdge_IsWithinTube_PointInside) {
    BrepModel body;
    int v0 = body.add_vertex(Point3D(0, 0, 0));
    int v1 = body.add_vertex(Point3D(10, 0, 0));
    body.add_edge(v0, v1);

    auto tes = build_tolerant_edges(body, 0.1);
    ASSERT_EQ(tes.size(), 1u);
    const auto& te = tes[0];

    // 线段中点上方 0.05（在管内）
    Point3D p_on_tube(5.0, 0.05, 0.0);
    EXPECT_TRUE(te.is_within_tube(p_on_tube));

    // 线段端点附近（在管内）
    Point3D p_near_start(0.0, 0.01, 0.01);
    EXPECT_TRUE(te.is_within_tube(p_near_start));
}

TEST(TolerantModelingTest, TolerantEdge_IsWithinTube_PointOutside) {
    BrepModel body;
    int v0 = body.add_vertex(Point3D(0, 0, 0));
    int v1 = body.add_vertex(Point3D(1, 0, 0));
    body.add_edge(v0, v1);

    auto tes = build_tolerant_edges(body, 1e-6);
    ASSERT_EQ(tes.size(), 1u);
    const auto& te = tes[0];

    // tube_radius ≈ 1e-6，距离 0.1 远大于管半径
    Point3D p_far(0.5, 0.1, 0.0);
    EXPECT_FALSE(te.is_within_tube(p_far));

    // 线段延长线方向远处点
    Point3D p_beyond(-1.0, 0.0, 0.0);
    EXPECT_FALSE(te.is_within_tube(p_beyond));
}

TEST(TolerantModelingTest, TolerantEdge_Intersects_TubesIntersect) {
    BrepModel body;
    int v0 = body.add_vertex(Point3D(0, 0, 0));
    int v1 = body.add_vertex(Point3D(10, 0, 0));
    int v2 = body.add_vertex(Point3D(5, -1, 0));
    int v3 = body.add_vertex(Point3D(5, 1, 0));
    body.add_edge(v0, v1);
    body.add_edge(v2, v3);

    auto tes = build_tolerant_edges(body, 0.5);
    ASSERT_EQ(tes.size(), 2u);

    // 两条边在空中交叉，管半径 0.5 足够覆盖交叉点
    tes[0].tube_radius = 0.5;
    tes[1].tube_radius = 0.5;
    EXPECT_TRUE(tes[0].intersects(tes[1]));
}

TEST(TolerantModelingTest, TolerantEdge_Intersects_TubesDisjoint) {
    BrepModel body;
    int v0 = body.add_vertex(Point3D(0, 0, 0));
    int v1 = body.add_vertex(Point3D(1, 0, 0));
    int v2 = body.add_vertex(Point3D(100, 0, 0));
    int v3 = body.add_vertex(Point3D(101, 0, 0));
    body.add_edge(v0, v1);
    body.add_edge(v2, v3);

    auto tes = build_tolerant_edges(body, 1e-6);
    ASSERT_EQ(tes.size(), 2u);
    EXPECT_FALSE(tes[0].intersects(tes[1]));
}

TEST(TolerantModelingTest, TolerantEdge_SegmentSegmentDistance_Parallel) {
    // 两条平行线段，距离为 1.0
    double dist = TolerantEdge::segment_segment_distance(
        Point3D(0, 0, 0), Point3D(10, 0, 0),
        Point3D(0, 1, 0), Point3D(10, 1, 0));
    EXPECT_NEAR(dist, 1.0, 1e-10);
}

TEST(TolerantModelingTest, TolerantEdge_SegmentSegmentDistance_Crossing) {
    // 两条在空中交叉但不接触的线段（最近距离 > 0）
    double dist = TolerantEdge::segment_segment_distance(
        Point3D(0, -1, 0), Point3D(0, 1, 0),
        Point3D(1, 0, -1), Point3D(1, 0, 1));
    EXPECT_NEAR(dist, 1.0, 1e-10);
}

TEST(TolerantModelingTest, TolerantEdge_SegmentSegmentDistance_Degenerate) {
    // 一个退化为点
    double dist = TolerantEdge::segment_segment_distance(
        Point3D(0, 0, 0), Point3D(0, 0, 0),    // 退化点
        Point3D(3, 4, 0), Point3D(3, 4, 0));   // 退化点
    EXPECT_NEAR(dist, 5.0, 1e-10);
}

TEST(TolerantModelingTest, TolerantEdge_Direction) {
    BrepModel body;
    int v0 = body.add_vertex(Point3D(0, 0, 0));
    int v1 = body.add_vertex(Point3D(0, 0, 5));
    body.add_edge(v0, v1);

    auto tes = build_tolerant_edges(body);
    ASSERT_EQ(tes.size(), 1u);
    auto dir = tes[0].direction();
    EXPECT_NEAR(dir.z(), 1.0, 1e-10);
}

// ═══════════════════════════════════════════════════════════
//  13. ToleranceConflict 结构体测试
// ═══════════════════════════════════════════════════════════

TEST(TolerantModelingTest, ToleranceConflict_DefaultConstruction) {
    ToleranceConflict tc;
    EXPECT_EQ(tc.element_id_a, -1);
    EXPECT_EQ(tc.element_id_b, -1);
    EXPECT_DOUBLE_EQ(tc.gap_size, 0.0);
    EXPECT_TRUE(tc.resolution.empty());
}

TEST(TolerantModelingTest, ToleranceConflict_VertexInSphere) {
    ToleranceConflict tc;
    tc.type = ConflictType::VertexInSphere;
    tc.element_id_a = 3;
    tc.element_id_b = 7;
    tc.gap_size = 1e-5;
    tc.resolution = "merge";

    EXPECT_TRUE(tc.is_vertex_conflict());
    EXPECT_FALSE(tc.is_edge_conflict());
    EXPECT_FALSE(tc.is_face_conflict());
}

TEST(TolerantModelingTest, ToleranceConflict_EdgeInTube) {
    ToleranceConflict tc;
    tc.type = ConflictType::EdgeInTube;
    tc.element_id_a = 1;
    tc.element_id_b = 2;
    tc.gap_size = 0.001;

    EXPECT_FALSE(tc.is_vertex_conflict());
    EXPECT_TRUE(tc.is_edge_conflict());
    EXPECT_FALSE(tc.is_face_conflict());
}

TEST(TolerantModelingTest, ToleranceConflict_FaceGap) {
    ToleranceConflict tc;
    tc.type = ConflictType::FaceGap;
    tc.element_id_a = 0;
    tc.element_id_b = 1;
    tc.gap_size = 0.05;

    EXPECT_FALSE(tc.is_vertex_conflict());
    EXPECT_FALSE(tc.is_edge_conflict());
    EXPECT_TRUE(tc.is_face_conflict());
}

// ═══════════════════════════════════════════════════════════
//  14. detect_tolerance_conflicts
// ═══════════════════════════════════════════════════════════

TEST(TolerantModelingTest, DetectConflicts_NoConflictsOnCleanModel) {
    // 一个标准盒子，顶点间距远大于容差，应该没有冲突
    auto box = make_box(2.0, 2.0, 2.0);
    auto conflicts = detect_tolerance_conflicts(box, 1e-6);
    // 可能只有少量（或无）冲突
    EXPECT_TRUE(conflicts.empty() || conflicts.size() < 3);
}

TEST(TolerantModelingTest, DetectConflicts_VertexConflict) {
    BrepModel body;
    // 两个非常接近但未合并的顶点
    int v0 = body.add_vertex(Point3D(0, 0, 0));
    int v1 = body.add_vertex(Point3D(1e-5, 1e-5, 1e-5));
    int v2 = body.add_vertex(Point3D(1, 0, 0));
    int v3 = body.add_vertex(Point3D(1, 1, 0));
    body.add_edge(v0, v2);
    body.add_edge(v2, v3);
    body.add_edge(v3, v1);
    body.add_edge(v1, v0);

    auto conflicts = detect_tolerance_conflicts(body, 1e-4, 2.0, 1e-4);

    // 应该检测到 v0 和 v1 的球体重叠
    bool found_vertex = false;
    for (const auto& c : conflicts) {
        if (c.type == ConflictType::VertexInSphere) {
            found_vertex = true;
            EXPECT_GT(c.gap_size, 0.0);
            EXPECT_LT(c.gap_size, 1e-4);
        }
    }
    EXPECT_TRUE(found_vertex) << "Should detect at least one VertexInSphere conflict";
}

TEST(TolerantModelingTest, DetectConflicts_EdgeConflict) {
    BrepModel body;
    // 两条近似平行但略微偏移的边，在靠近的地方管会相交
    int v0 = body.add_vertex(Point3D(0, 0, 0));
    int v1 = body.add_vertex(Point3D(10, 0, 0));
    int v2 = body.add_vertex(Point3D(4.99, 0.001, 0));
    int v3 = body.add_vertex(Point3D(5.01, 0.002, 0));
    body.add_edge(v0, v1);
    body.add_edge(v2, v3);

    // 用较大的 edge_tolerance 确保管相交被检测到
    auto conflicts = detect_tolerance_conflicts(body, 1e-3, 5.0, 1e-4);

    bool found_edge = false;
    for (const auto& c : conflicts) {
        if (c.type == ConflictType::EdgeInTube) {
            found_edge = true;
        }
    }
    // 可能检测到，取决于具体容差设置
    // 不强制要求，但验证不崩溃
    SUCCEED();
}

TEST(TolerantModelingTest, DetectConflicts_FaceGap) {
    BrepModel body;
    // 创建一个开放面（有自由边）
    int v0 = body.add_vertex(Point3D(0, 0, 0));
    int v1 = body.add_vertex(Point3D(1, 0, 0));
    int v2 = body.add_vertex(Point3D(1, 1, 0));
    int v3 = body.add_vertex(Point3D(0, 1, 0));
    int e0 = body.add_edge(v0, v1);
    int e1 = body.add_edge(v1, v2);
    int e2 = body.add_edge(v2, v3);
    int e3 = body.add_edge(v3, v0);

    auto surf = make_plane_surface();
    int sid = body.add_surface(surf);
    body.add_face(sid, {e0, e1, e2, e3});

    // 另外一条靠近面边界的孤立边
    int v4 = body.add_vertex(Point3D(0.0001, 0.5, 0.0));
    int v5 = body.add_vertex(Point3D(-0.0001, 0.5, 0.0));
    body.add_edge(v4, v5);

    auto conflicts = detect_tolerance_conflicts(body, 1e-6, 2.0, 1e-2);
    // 验证不崩溃
    SUCCEED();
}

TEST(TolerantModelingTest, DetectConflicts_EmptyBody) {
    BrepModel body;
    auto conflicts = detect_tolerance_conflicts(body);
    EXPECT_TRUE(conflicts.empty());
}

// ═══════════════════════════════════════════════════════════
//  15. resolve_tolerance_conflicts
// ═══════════════════════════════════════════════════════════

TEST(TolerantModelingTest, ResolveConflicts_Empty) {
    BrepModel body;
    std::vector<ToleranceConflict> conflicts;
    int resolved = resolve_tolerance_conflicts(body, conflicts);
    EXPECT_EQ(resolved, 0);
}

TEST(TolerantModelingTest, ResolveConflicts_VertexInSphere) {
    BrepModel body = make_triangle(
        Point3D(0, 0, 0), Point3D(1, 0, 0), Point3D(0.5, 0.866, 0));

    // 添加一个与现有顶点非常接近的顶点
    body.add_vertex(Point3D(1e-7, 1e-7, 1e-7));

    size_t before = body.num_vertices();
    std::vector<ToleranceConflict> conflicts;
    ToleranceConflict c;
    c.type = ConflictType::VertexInSphere;
    c.element_id_a = 0;
    c.element_id_b = 3;
    c.gap_size = 2e-7;
    c.resolution = "merge";
    conflicts.push_back(c);

    int resolved = resolve_tolerance_conflicts(body, conflicts);
    EXPECT_GE(resolved, 0); // 可能有/无合并，取决于实现
}

TEST(TolerantModelingTest, ResolveConflicts_AllTypes) {
    // 验证 resolve_tolerance_conflicts 可以处理所有三种冲突类型
    BrepModel body = make_triangle(
        Point3D(0, 0, 0), Point3D(1, 0, 0), Point3D(0, 1, 0));

    std::vector<ToleranceConflict> conflicts;
    {
        ToleranceConflict c;
        c.type = ConflictType::VertexInSphere;
        c.element_id_a = 0;
        c.element_id_b = 1;
        c.gap_size = 1e-6;
        c.resolution = "merge vertices";
        conflicts.push_back(c);
    }
    {
        ToleranceConflict c;
        c.type = ConflictType::EdgeInTube;
        c.element_id_a = 0;
        c.element_id_b = 1;
        c.gap_size = 1e-4;
        c.resolution = "merge edges";
        conflicts.push_back(c);
    }
    {
        ToleranceConflict c;
        c.type = ConflictType::FaceGap;
        c.element_id_a = 0;
        c.element_id_b = 1;
        c.gap_size = 1e-4;
        c.resolution = "bridge gap";
        conflicts.push_back(c);
    }

    int resolved = resolve_tolerance_conflicts(body, conflicts);
    EXPECT_GE(resolved, 0);
}

// ═══════════════════════════════════════════════════════════
//  16. 端到端：检测 + 修复流水线
// ═══════════════════════════════════════════════════════════

TEST(TolerantModelingTest, EndToEnd_DetectAndResolve) {
    BrepModel body;
    // 创建两个非常接近的顶点 → 应检测到 VertexInSphere 并合并
    int v0 = body.add_vertex(Point3D(0, 0, 0));
    int v1 = body.add_vertex(Point3D(1e-5, 1e-5, 1e-5));
    int v2 = body.add_vertex(Point3D(1, 0, 0));
    int v3 = body.add_vertex(Point3D(0, 1, 0));

    body.add_edge(v0, v2);
    body.add_edge(v2, v3);
    body.add_edge(v3, v1);

    auto surf = make_plane_surface();
    int sid = body.add_surface(surf);
    body.add_face(sid, {0, 1, 2});

    size_t before = body.num_vertices();

    // 检测冲突
    auto conflicts = detect_tolerance_conflicts(body, 1e-4, 2.0, 1e-4);

    // 修复冲突
    int resolved = resolve_tolerance_conflicts(body, conflicts);

    // 验证：至少尝试了修复（不崩溃即可）
    EXPECT_GE(resolved, 0);
    SUCCEED();
}