#include <gtest/gtest.h>
#include <cmath>
#include "vde/sdf/sdf_operations.h"

using namespace vde::sdf;
using vde::core::Point3D;

// ── Minimal inline primitives for testing (no sdf_primitives dependency) ──

inline double sdf_sphere(const Point3D& p, double r = 1.0) {
    return std::sqrt(p.x()*p.x() + p.y()*p.y() + p.z()*p.z()) - r;
}

inline double sdf_box(const Point3D& p, const Point3D& b) {
    auto q = Point3D(std::abs(p.x()) - b.x(),
                     std::abs(p.y()) - b.y(),
                     std::abs(p.z()) - b.z());
    return std::max({q.x(), q.y(), q.z(), 0.0}) +
           std::min(std::max({q.x(), q.y(), q.z()}), 0.0);
}

// ═══════════════════════════════════════════════════
//  Sharp Boolean Operations
// ═══════════════════════════════════════════════════

TEST(SdfOperations, Union) {
    EXPECT_DOUBLE_EQ(op_union(1.0, 2.0), 1.0);
    EXPECT_DOUBLE_EQ(op_union(-1.0, 2.0), -1.0);
    EXPECT_DOUBLE_EQ(op_union(3.0, -1.0), -1.0);
    EXPECT_DOUBLE_EQ(op_union(-3.0, -1.0), -3.0);
}

TEST(SdfOperations, Intersection) {
    EXPECT_DOUBLE_EQ(op_intersection(1.0, 2.0), 2.0);
    EXPECT_DOUBLE_EQ(op_intersection(-1.0, 2.0), 2.0);
    EXPECT_DOUBLE_EQ(op_intersection(3.0, -1.0), 3.0);
    EXPECT_DOUBLE_EQ(op_intersection(-3.0, -1.0), -1.0);
}

TEST(SdfOperations, Difference) {
    // d1 is the body, d2 is the cutter
    // difference = max(d1, -d2)
    EXPECT_DOUBLE_EQ(op_difference(1.0, 2.0), 1.0);   // max(1,-2)=1
    EXPECT_DOUBLE_EQ(op_difference(3.0, 2.0), 3.0);   // max(3,-2)=3
    EXPECT_DOUBLE_EQ(op_difference(-1.0, 2.0), -1.0); // max(-1,-2)=-1
    EXPECT_DOUBLE_EQ(op_difference(2.0, -3.0), 3.0);  // max(2,3)=3
}

TEST(SdfOperations, UnionIdentity) {
    // Union with positive infinity yields the other value
    double inf = std::numeric_limits<double>::infinity();
    EXPECT_DOUBLE_EQ(op_union(5.0, inf), 5.0);
    EXPECT_DOUBLE_EQ(op_union(inf, 5.0), 5.0);
}

TEST(SdfOperations, IntersectionIdentity) {
    double inf = std::numeric_limits<double>::infinity();
    EXPECT_DOUBLE_EQ(op_intersection(5.0, -inf), 5.0);
    EXPECT_DOUBLE_EQ(op_intersection(-inf, 5.0), 5.0);
}

// ═══════════════════════════════════════════════════
//  Smooth Boolean Operations
// ═══════════════════════════════════════════════════

TEST(SdfOperations, SmoothUnionFallsBackToSharp) {
    // k=0 should fall back to sharp union
    EXPECT_DOUBLE_EQ(op_smooth_union(1.0, 2.0, 0.0), 1.0);
    EXPECT_DOUBLE_EQ(op_smooth_union(-1.0, 2.0, 0.0), -1.0);
    // k negative should also fall back
    EXPECT_DOUBLE_EQ(op_smooth_union(1.0, 2.0, -5.0), 1.0);
}

TEST(SdfOperations, SmoothUnionBlending) {
    // With k > 0, result should be less than min(d1,d2) (blend digs in)
    double k = 0.1;
    double result = op_smooth_union(1.0, 1.0, k);
    EXPECT_LT(result, 1.0);            // blend reduces distance
    EXPECT_GE(result, 1.0 - k * 0.25); // bound: max reduction is k/4 at h=0.5

    // Far apart — should approach sharp union
    double far_result = op_smooth_union(1.0, 10.0, 0.1);
    EXPECT_NEAR(far_result, 1.0, 0.01);
}

TEST(SdfOperations, SmoothIntersectionFallsBackToSharp) {
    EXPECT_DOUBLE_EQ(op_smooth_intersection(1.0, 2.0, 0.0), 2.0);
    EXPECT_DOUBLE_EQ(op_smooth_intersection(1.0, 2.0, -1.0), 2.0);
}

TEST(SdfOperations, SmoothIntersectionBlending) {
    double k = 0.1;
    double result = op_smooth_intersection(1.0, 1.0, k);
    EXPECT_GT(result, 1.0);            // blend increases distance
    EXPECT_LE(result, 1.0 + k * 0.25); // bound: max increase is k/4 at h=0.5
}

TEST(SdfOperations, SmoothDifferenceFallsBackToSharp) {
    EXPECT_DOUBLE_EQ(op_smooth_difference(1.0, 2.0, 0.0), 1.0);
    EXPECT_DOUBLE_EQ(op_smooth_difference(-1.0, 2.0, 0.0), -1.0);
}

// ═══════════════════════════════════════════════════
//  Shape Modifiers
// ═══════════════════════════════════════════════════

TEST(SdfOperations, Round) {
    EXPECT_DOUBLE_EQ(op_round(5.0, 2.0), 3.0);
    EXPECT_DOUBLE_EQ(op_round(-1.0, 0.5), -1.5);
    EXPECT_DOUBLE_EQ(op_round(0.0, 3.0), -3.0);
}

TEST(SdfOperations, Onion) {
    // Standard op_onion: abs(d) - thickness
    EXPECT_DOUBLE_EQ(op_onion(0.0, 2.0), -2.0);   // abs(0) - 2 = -2
    EXPECT_DOUBLE_EQ(op_onion(2.0, 2.0), 0.0);    // abs(2) - 2 = 0
    EXPECT_DOUBLE_EQ(op_onion(-2.0, 2.0), 0.0);   // abs(-2) - 2 = 0
    EXPECT_DOUBLE_EQ(op_onion(0.5, 2.0), -1.5);   // abs(0.5) - 2 = -1.5
}

TEST(SdfOperations, OnionSphere) {
    // Sphere of radius 1 with thickness 0.2 creates a shell
    // abs(d) - 0.2 → inner surface at r=0.8, outer at r=1.2
    double d = sdf_sphere(Point3D(0, 0, 0.8));
    double shell = op_onion(d, 0.2);
    EXPECT_NEAR(shell, 0.0, 1e-10);  // inner surface at r=0.8

    d = sdf_sphere(Point3D(0, 0, 1.0));
    shell = op_onion(d, 0.2);
    EXPECT_NEAR(shell, -0.2, 1e-10); // inside shell at r=1.0
}

// ═══════════════════════════════════════════════════
//  Domain Deformations
// ═══════════════════════════════════════════════════

TEST(SdfOperations, RepeatIdentity) {
    // repeat with zero cell size = no repetition
    auto p = Point3D(5.0, 3.0, -2.0);
    auto result = op_repeat(p, Point3D(0, 0, 0));
    EXPECT_DOUBLE_EQ(result.x(), p.x());
    EXPECT_DOUBLE_EQ(result.y(), p.y());
    EXPECT_DOUBLE_EQ(result.z(), p.z());
}

TEST(SdfOperations, RepeatMapsToUnitCell) {
    // With cell size (2,2,2), all points should map to [-1, 1]
    auto c = Point3D(2.0, 2.0, 2.0);

    // Center of cell → maps to 0
    auto r1 = op_repeat(Point3D(0, 0, 0), c);
    EXPECT_NEAR(r1.x(), 0.0, 1e-10);
    EXPECT_NEAR(r1.y(), 0.0, 1e-10);
    EXPECT_NEAR(r1.z(), 0.0, 1e-10);

    // Near cell boundary → maps to ±1 (avoid exact ties with round())
    auto r2 = op_repeat(Point3D(0.999, 0.999, 0.999), c);
    EXPECT_NEAR(r2.x(), 0.999, 1e-10);
    EXPECT_NEAR(r2.y(), 0.999, 1e-10);
    EXPECT_NEAR(r2.z(), 0.999, 1e-10);

    // Outside the cell
    auto r3 = op_repeat(Point3D(3.5, 2.5, 1.5), c);
    EXPECT_NEAR(r3.x(), -0.5, 1e-10);  // 3.5 - 2*2 = -0.5
    EXPECT_NEAR(r3.y(), 0.5, 1e-10);   // 2.5 - 1*2 = 0.5
    EXPECT_NEAR(r3.z(), -0.5, 1e-10);  // 1.5 - 1*2 = -0.5
}

TEST(SdfOperations, RepeatSingleAxis) {
    // Only repeat along X
    auto c = Point3D(3.0, 0.0, 0.0);
    auto r = op_repeat(Point3D(5.0, 2.0, 1.0), c);
    EXPECT_NEAR(r.x(), -1.0, 1e-10);   // 5 - 2*3 = -1
    EXPECT_DOUBLE_EQ(r.y(), 2.0);       // unchanged
    EXPECT_DOUBLE_EQ(r.z(), 1.0);       // unchanged
}

TEST(SdfOperations, RepeatSphereGrid) {
    // Repeated sphere: check that sphere exists at multiple cell positions
    auto sphere_repeated = [](const Point3D& p) -> double {
        return sdf_sphere(op_repeat(p, Point3D(3.0, 3.0, 3.0)), 0.5);
    };

    // Center of any cell should be inside the sphere
    EXPECT_LT(sphere_repeated(Point3D(0, 0, 0)), 0.0);
    EXPECT_LT(sphere_repeated(Point3D(3, 0, 0)), 0.0);
    EXPECT_LT(sphere_repeated(Point3D(-3, 6, -9)), 0.0);

    // Midpoint between cells should be outside
    EXPECT_GT(sphere_repeated(Point3D(1.5, 0, 0)), 0.0);
    EXPECT_GT(sphere_repeated(Point3D(0, 1.5, 0)), 0.0);
}

TEST(SdfOperations, Mirror) {
    // Mirror across X=0: everything maps to x >= 0
    auto r1 = op_mirror_x(Point3D(3.0, 1.0, 1.0));
    EXPECT_DOUBLE_EQ(r1.x(), 3.0);  // positive stays positive
    EXPECT_DOUBLE_EQ(r1.y(), 1.0);
    EXPECT_DOUBLE_EQ(r1.z(), 1.0);

    auto r2 = op_mirror_x(Point3D(-3.0, 2.0, 2.0));
    EXPECT_DOUBLE_EQ(r2.x(), 3.0);  // negative folds to positive
    EXPECT_DOUBLE_EQ(r2.y(), 2.0);
    EXPECT_DOUBLE_EQ(r2.z(), 2.0);

    // With offset
    auto r3 = op_mirror_x(Point3D(-3.0, 0, 0), 1.0);
    EXPECT_DOUBLE_EQ(r3.x(), 5.0);  // 1 + abs(-3 - 1) = 1 + 4 = 5
}

TEST(SdfOperations, RotateY) {
    // 90° rotation around Y: (1,0,0) → (0,0,-1)
    auto r1 = op_rotate(Point3D(1, 0, 0), M_PI / 2.0);
    EXPECT_NEAR(r1.x(), 0.0, 1e-10);
    EXPECT_NEAR(r1.y(), 0.0, 1e-10);
    EXPECT_NEAR(r1.z(), -1.0, 1e-10);

    // 180° rotation: (1,0,0) → (-1,0,0)
    auto r2 = op_rotate(Point3D(1, 0, 0), M_PI);
    EXPECT_NEAR(r2.x(), -1.0, 1e-10);

    // 360° → identity
    auto r3 = op_rotate(Point3D(3.0, 2.0, 1.0), 2.0 * M_PI);
    EXPECT_NEAR(r3.x(), 3.0, 1e-10);
    EXPECT_NEAR(r3.y(), 2.0, 1e-10);
    EXPECT_NEAR(r3.z(), 1.0, 1e-10);
}

TEST(SdfOperations, Translate) {
    auto r = op_translate(Point3D(5, 3, 1), Point3D(2, 1, 0));
    EXPECT_DOUBLE_EQ(r.x(), 3.0);  // 5 - 2
    EXPECT_DOUBLE_EQ(r.y(), 2.0);  // 3 - 1
    EXPECT_DOUBLE_EQ(r.z(), 1.0);  // 1 - 0
}

TEST(SdfOperations, Scale) {
    auto s = Point3D(2.0, 4.0, 0.5);
    auto r = op_scale(Point3D(4, 8, 1), s);
    EXPECT_DOUBLE_EQ(r.x(), 2.0);
    EXPECT_DOUBLE_EQ(r.y(), 2.0);
    EXPECT_DOUBLE_EQ(r.z(), 2.0);
}

TEST(SdfOperations, Twist) {
    // At y=0, twist has no effect (angle = 0)
    auto r1 = op_twist(Point3D(1, 0, 0), 1.0);
    EXPECT_NEAR(r1.x(), 1.0, 1e-10);
    EXPECT_NEAR(r1.z(), 0.0, 1e-10);

    // At y>0, twist rotates in xz plane
    auto r2 = op_twist(Point3D(1, 0, 0), 0.5);  // still y=0 so no twist
    EXPECT_NEAR(r2.x(), 1.0, 1e-10);
    EXPECT_NEAR(r2.z(), 0.0, 1e-10);

    // Twist should be invertible: twist of -amount should cancel
    auto p = Point3D(1.5, 2.0, 0.5);
    auto twisted = op_twist(p, 0.3);
    // Length should be preserved (rotation preserves norm in xz plane)
    double orig_xz_len = std::sqrt(p.x()*p.x() + p.z()*p.z());
    double twisted_xz_len = std::sqrt(twisted.x()*twisted.x() + twisted.z()*twisted.z());
    EXPECT_NEAR(orig_xz_len, twisted_xz_len, 1e-10);
    EXPECT_DOUBLE_EQ(twisted.y(), p.y());  // y unchanged
}

TEST(SdfOperations, Bend) {
    // No bend: amount=0 → identity
    auto p = Point3D(1.0, 2.0, 3.0);
    auto r = op_bend(p, 0.0);
    EXPECT_NEAR(r.x(), p.x(), 1e-10);
    EXPECT_NEAR(r.y(), p.y(), 1e-10);
    EXPECT_NEAR(r.z(), p.z(), 1e-10);

    // Bend with small amount produces valid coordinates
    auto r2 = op_bend(p, 0.1);
    EXPECT_TRUE(std::isfinite(r2.x()));
    EXPECT_TRUE(std::isfinite(r2.y()));
    EXPECT_TRUE(std::isfinite(r2.z()));
}

TEST(SdfOperations, Elongate) {
    auto f = Point3D(2.0, 1.0, 0.5);
    auto r = op_elongate(Point3D(4, 3, 2), f);
    EXPECT_DOUBLE_EQ(r.x(), 2.0);
    EXPECT_DOUBLE_EQ(r.y(), 2.0);
    EXPECT_DOUBLE_EQ(r.z(), 1.5);
}

TEST(SdfOperations, Displace) {
    // At origin, all sin terms = 0 → no displacement
    double d = op_displace(1.0, Point3D(0, 0, 0), 0.5, 2.0);
    EXPECT_DOUBLE_EQ(d, 1.0);

    // Displacement is bounded by amplitude
    double d2 = op_displace(1.0, Point3D(1.0, 2.0, 3.0), 0.5, 1.0);
    EXPECT_GE(d2, 0.5);
    EXPECT_LE(d2, 1.5);
}

TEST(SdfOperations, CheapBend) {
    // No bend: k=0 → identity
    auto p = Point3D(2.0, 3.0, 4.0);
    auto r1 = op_cheap_bend(p, 0.0);
    EXPECT_NEAR(r1.x(), p.x(), 1e-10);
    EXPECT_NEAR(r1.y(), p.y(), 1e-10);
    EXPECT_NEAR(r1.z(), p.z(), 1e-10);

    // At x=0, cheap bend has no effect (sin(0)=0, cos(0)=1)
    auto r2 = op_cheap_bend(Point3D(0, 3, 1), 1.0);
    EXPECT_NEAR(r2.x(), 0.0, 1e-10);
    EXPECT_NEAR(r2.y(), 3.0, 1e-10);
    EXPECT_NEAR(r2.z(), 1.0, 1e-10);
}

// ═══════════════════════════════════════════════════
//  Composition Tests
// ═══════════════════════════════════════════════════

TEST(SdfOperations, CompositionRepeatTwistSphere) {
    // Repeat + twist + sphere: sphere repeated in grid, then twisted
    auto composed = [](const Point3D& p) -> double {
        auto q = op_repeat(p, Point3D(2.0, 2.0, 2.0));
        q = op_twist(q, 0.5);
        return sdf_sphere(q, 0.3);
    };

    // Near origin (center of a cell) should be inside sphere
    EXPECT_LT(composed(Point3D(0, 0, 0)), 0.0);

    // Further away in the grid should also have spheres
    // (repeat maps cell centers to origin)
    EXPECT_LT(composed(Point3D(2, 0, 0)), 0.0);
    EXPECT_LT(composed(Point3D(0, 2, 0)), 0.0);

    // Away from cell centers should be outside
    EXPECT_GT(composed(Point3D(1.0, 1.0, 1.0)), 0.0);
}

TEST(SdfOperations, CompositionBooleanWithDeformations) {
    // Union of two translated spheres
    auto scene = [](const Point3D& p) -> double {
        double d1 = sdf_sphere(op_translate(p, Point3D(1.5, 0, 0)), 1.0);
        double d2 = sdf_sphere(op_translate(p, Point3D(-1.5, 0, 0)), 1.0);
        return op_union(d1, d2);
    };

    // Between the two spheres (origin) should be outside
    EXPECT_GT(scene(Point3D(0, 0, 0)), 0.0);

    // Center of each sphere should be inside
    EXPECT_LT(scene(Point3D(1.5, 0, 0)), 0.0);
    EXPECT_LT(scene(Point3D(-1.5, 0, 0)), 0.0);
}

TEST(SdfOperations, CompositionSmoothUnionSpheres) {
    auto scene = [](const Point3D& p) -> double {
        double d1 = sdf_sphere(op_translate(p, Point3D(1.0, 0, 0)), 1.0);
        double d2 = sdf_sphere(op_translate(p, Point3D(-1.0, 0, 0)), 1.0);
        return op_smooth_union(d1, d2, 0.3);
    };

    // Midpoint between spheres should be within the blend region
    double d = scene(Point3D(0, 0, 0));
    // Both spheres at origin: distance = sqrt(1^2)-1 = 0
    // h = clamp(0.5 + 0.5*(0-0)/0.3, 0, 1) = 0.5
    // mix(0,0,0.5) - 0.3*0.5*0.5 = 0 - 0.075 = -0.075
    EXPECT_LT(d, 0.0);  // should be inside blend region
    EXPECT_GT(d, -0.3); // but not too deep
}

TEST(SdfOperations, CompositionDifferenceWithTwist) {
    // Sphere minus a smaller twisted sphere
    auto scene = [](const Point3D& p) -> double {
        double body = sdf_sphere(p, 2.0);
        auto q = op_twist(p, 1.0);
        double cutter = sdf_sphere(q, 1.0);
        return op_difference(body, cutter);
    };

    // At origin, both spheres contain the point
    // body: sqrt(0) - 2 = -2; cutter: sqrt(0) - 1 = -1
    // difference = max(-2, -(-1)) = max(-2, 1) = 1 → outside!
    EXPECT_GT(scene(Point3D(0, 0, 0)), 0.0);

    // At r=1.5 from origin: body=-0.5, cutter=0.5 (at y=0 twist=0 → sphere at r=1)
    // difference = max(0.5, 0.5) = 0.5 → outside
    // Actually let's test a clear case: far outside both
    EXPECT_GT(scene(Point3D(3.0, 0, 0)), 0.0);  // far outside
}

TEST(SdfOperations, MultipleDeformationsChain) {
    // Translate → rotate → twist → repeat → sphere
    auto composed = [](const Point3D& p) -> double {
        auto q = op_translate(p, Point3D(1.0, 0.0, 0.0));
        q = op_rotate(q, M_PI / 4.0);
        q = op_repeat(q, Point3D(3.0, 3.0, 3.0));
        return sdf_sphere(q, 0.5);
    };

    // Should not crash or produce NaN
    double d = composed(Point3D(0, 0, 0));
    EXPECT_TRUE(std::isfinite(d));

    // Check at multiple points
    for (double x = -4.0; x <= 4.0; x += 2.0) {
        for (double y = -4.0; y <= 4.0; y += 2.0) {
            for (double z = -4.0; z <= 4.0; z += 2.0) {
                double val = composed(Point3D(x, y, z));
                EXPECT_TRUE(std::isfinite(val));
            }
        }
    }
}