#include <gtest/gtest.h>
#include "vde/brep/tolerance.h"
#include "vde/brep/modeling.h"

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

TEST(ToleranceTest, FuzzyEqual_Exact) {
    EXPECT_TRUE(fuzzy_equal(1.0, 1.0));
}

TEST(ToleranceTest, FuzzyEqual_WithinTol) {
    EXPECT_TRUE(fuzzy_equal(1.0, 1.0 + 1e-10));
}

TEST(ToleranceTest, FuzzyEqual_OutsideTol) {
    EXPECT_FALSE(fuzzy_equal(1.0, 1.0 + 1e-3, 1e-6));
}

TEST(ToleranceTest, FuzzyZero) {
    EXPECT_TRUE(fuzzy_zero(0.0));
    EXPECT_TRUE(fuzzy_zero(1e-10));
    EXPECT_FALSE(fuzzy_zero(1e-3, 1e-6));
}

TEST(ToleranceTest, FuzzyVec) {
    Vector3D a(1, 2, 3);
    Vector3D b(1 + 1e-10, 2, 3 - 1e-10);
    EXPECT_TRUE(fuzzy_equal_vec(a, b, 1e-8));
}

TEST(ToleranceTest, FuzzyPoint) {
    Point3D a(0, 0, 0);
    Point3D b(1e-10, 0, 0);
    EXPECT_TRUE(fuzzy_equal_point(a, b, 1e-8));
}

TEST(ToleranceTest, FuzzyParallel) {
    Vector3D a(1, 0, 0);
    Vector3D b(1, 1e-11, 0);
    EXPECT_TRUE(fuzzy_parallel(a, b));
}

TEST(ToleranceTest, FuzzyPerpendicular) {
    Vector3D a(1, 0, 0);
    Vector3D b(0, 1, 0);
    EXPECT_TRUE(fuzzy_perpendicular(a, b));
}

TEST(ToleranceTest, AdaptiveTolerance) {
    double t1 = adaptive_tolerance(1.0);     // 1mm model
    double t2 = adaptive_tolerance(1000.0);  // 1m model
    EXPECT_GE(t2, t1);  // larger model → larger tolerance
}

TEST(ToleranceTest, ModelTolerance_Box) {
    auto box = make_box(100, 100, 100);
    double t = model_tolerance(box);
    EXPECT_GT(t, 0.0);
}

TEST(ToleranceTest, GlobalConfig) {
    auto& cfg = ToleranceConfig::global();
    EXPECT_GT(cfg.vertex_merge, 0.0);

    ToleranceConfig custom;
    custom.vertex_merge = 1e-4;
    ToleranceConfig::set_global(custom);
    EXPECT_EQ(ToleranceConfig::global().vertex_merge, 1e-4);

    // Reset
    ToleranceConfig::set_global(ToleranceConfig{});
}

TEST(ToleranceTest, FuzzyGTE) {
    EXPECT_TRUE(fuzzy_gte(1.0, 1.0 - 1e-10));
    EXPECT_TRUE(fuzzy_gte(1.0, 1.0));
    EXPECT_FALSE(fuzzy_gte(1.0, 1.1, 1e-6));
}

TEST(ToleranceTest, FuzzyLTE) {
    EXPECT_TRUE(fuzzy_lte(1.0, 1.0 + 1e-10));
    EXPECT_TRUE(fuzzy_lte(1.0, 1.0));
    EXPECT_FALSE(fuzzy_lte(1.0, 0.9, 1e-6));
}

TEST(ToleranceTest, ToleranceConfig_AllDefaultPositive) {
    ToleranceConfig cfg;
    EXPECT_GT(cfg.vertex_merge, 0);
    EXPECT_GT(cfg.edge_merge, 0);
    EXPECT_GT(cfg.boolean, 0);
    EXPECT_GT(cfg.angular, 0);
}