#pragma once
#include "vde/core/point.h"
#include <cmath>
#include <algorithm>

namespace vde::sdf {

using core::Point3D;
using core::Vector3D;

// ── Boolean operations on distance values ──

[[nodiscard]] inline double op_union(double d1, double d2) {
    return std::min(d1, d2);
}

[[nodiscard]] inline double op_intersection(double d1, double d2) {
    return std::max(d1, d2);
}

[[nodiscard]] inline double op_difference(double d1, double d2) {
    return std::max(d1, -d2);
}

[[nodiscard]] inline double op_smooth_union(double d1, double d2, double k) {
    if (k <= 0.0) return std::min(d1, d2);
    double h = std::clamp(0.5 + 0.5 * (d1 - d2) / k, 0.0, 1.0);
    return d1 * (1.0 - h) + d2 * h - k * h * (1.0 - h);
}

[[nodiscard]] inline double op_smooth_intersection(double d1, double d2, double k) {
    if (k <= 0.0) return std::max(d1, d2);
    double h = std::clamp(0.5 - 0.5 * (d1 - d2) / k, 0.0, 1.0);
    return d1 * (1.0 - h) + d2 * h + k * h * (1.0 - h);
}

[[nodiscard]] inline double op_smooth_difference(double d1, double d2, double k) {
    if (k <= 0.0) return std::max(d1, -d2);
    double h = std::clamp(0.5 - 0.5 * (d2 + d1) / k, 0.0, 1.0);
    return d1 * (1.0 - h) + (-d2) * h + k * h * (1.0 - h);
}

// ── Modifiers (operate on a distance value) ──

[[nodiscard]] inline double op_round(double d, double r) {
    return d - r;
}

[[nodiscard]] inline double op_onion(double d, double thickness) {
    return std::abs(d) - thickness * 0.5;
}

// ── Domain deformation operators (transform point space) ──

/// Infinite repetition in a cell
[[nodiscard]] inline Point3D op_repeat(const Point3D& p, const Point3D& cell) {
    auto wrap = [](double v, double c) {
        return c > 0.0 ? v - c * std::round(v / c) : v;
    };
    return Point3D(wrap(p.x(), cell.x()),
                   wrap(p.y(), cell.y()),
                   wrap(p.z(), cell.z()));
}

/// Mirror across X=0 plane, with optional offset
[[nodiscard]] inline Point3D op_mirror_x(const Point3D& p, double offset = 0.0) {
    return Point3D(offset + std::abs(p.x() - offset), p.y(), p.z());
}

/// Mirror across Y=0
[[nodiscard]] inline Point3D op_mirror_y(const Point3D& p) {
    return Point3D(p.x(), std::abs(p.y()), p.z());
}

/// Mirror across Z=0
[[nodiscard]] inline Point3D op_mirror_z(const Point3D& p) {
    return Point3D(p.x(), p.y(), std::abs(p.z()));
}

/// Translate space (inverse for SDF: move the world, not the object)
[[nodiscard]] inline Point3D op_translate(const Point3D& p, const Point3D& offset) {
    return p - offset;
}

/// Rotate around Y axis by angle_rad (inverse for SDF)
[[nodiscard]] inline Point3D op_rotate(const Point3D& p, double angle_rad) {
    double c = std::cos(-angle_rad);
    double s = std::sin(-angle_rad);
    return Point3D(p.x() * c - p.z() * s, p.y(), p.x() * s + p.z() * c);
}

/// Non-uniform scale (inverse for SDF)
[[nodiscard]] inline Point3D op_scale(const Point3D& p, const Point3D& s) {
    return Point3D(p.x() / s.x(), p.y() / s.y(), p.z() / s.z());
}

/// Twist space around Y axis
[[nodiscard]] inline Point3D op_twist(const Point3D& p, double amount) {
    double c = std::cos(amount * p.y());
    double s = std::sin(amount * p.y());
    return Point3D(p.x() * c - p.z() * s, p.y(), p.x() * s + p.z() * c);
}

/// Bend space
[[nodiscard]] inline Point3D op_bend(const Point3D& p, double k) {
    double c = std::cos(k * p.x());
    double s = std::sin(k * p.x());
    return Point3D(c * p.x() - s * p.y(), s * p.x() + c * p.y(), p.z());
}

/// Elongate (stretch space, eliminating interior along major axes)
[[nodiscard]] inline Point3D op_elongate(const Point3D& p, const Point3D& h) {
    Point3D q = p.cwiseAbs() - h;
    return Point3D(
        q.x() > 0.0 ? p.x() - std::copysign(h.x(), p.x()) : 0.0,
        q.y() > 0.0 ? p.y() - std::copysign(h.y(), p.y()) : 0.0,
        q.z() > 0.0 ? p.z() - std::copysign(h.z(), p.z()) : 0.0
    );
}

/// Cheap bend (simplified bending)
[[nodiscard]] inline Point3D op_cheap_bend(const Point3D& p, double k) {
    double c = std::cos(k * p.x());
    double s = std::sin(k * p.x());
    return Point3D(p.x(), p.y() * c - p.z() * s, p.y() * s + p.z() * c);
}

/// Displace distance field with sinusoidal noise
[[nodiscard]] inline double op_displace(double d, const Point3D& p,
                                         double amplitude, double frequency) {
    double noise = std::sin(p.x() * frequency) *
                   std::sin(p.y() * frequency) *
                   std::sin(p.z() * frequency);
    return d + amplitude * noise;
}

} // namespace vde::sdf