"""
SDF Primitives - Core geometric shape representations as Signed Distance Fields.
Following GeoSDF paper methodology.

This module contains:
- Math utilities for quartic solving (Appendix B)
- SDF primitive classes (Circle, Ellipse, Hyperbola, Parabola, Line, etc.)
"""

import torch
import torch.nn as nn
from typing import Tuple

# Device configuration
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')


# =============================================================================
# Quartic Solver Utilities (Following Paper Appendix B)
# =============================================================================

def solve_cubic_one_real_batch(a: torch.Tensor, b: torch.Tensor, c: torch.Tensor, 
                                d: torch.Tensor) -> torch.Tensor:
    """Find one real root of cubic equation using Cardano's formula."""
    a_safe = a + 1e-10 * torch.sign(a + 1e-20)
    p = b / a_safe
    q = c / a_safe
    r = d / a_safe
    
    alpha = q - p**2 / 3
    beta = 2 * p**3 / 27 - p * q / 3 + r
    discriminant = (beta / 2)**2 + (alpha / 3)**3
    sqrt_disc = torch.sqrt(torch.clamp(discriminant, min=0) + 1e-12)
    
    term1 = -beta / 2 + sqrt_disc
    term2 = -beta / 2 - sqrt_disc
    
    def safe_cbrt(x):
        return torch.sign(x) * torch.pow(torch.abs(x) + 1e-12, 1/3)
    
    u = safe_cbrt(term1)
    v = safe_cbrt(term2)
    
    return u + v - p / 3


def hyperbola_distance_quartic(px: torch.Tensor, py: torch.Tensor, 
                                a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
    """Compute exact distance from point to hyperbola using Newton iteration."""
    px_abs = torch.abs(px)
    py_abs = torch.abs(py)
    
    t = torch.asinh(py_abs / (b + 1e-8))
    t = torch.clamp(t, 0.01, 10.0)
    
    for _ in range(15):
        cosh_t = torch.cosh(t)
        sinh_t = torch.sinh(t)
        hx = a * cosh_t
        hy = b * sinh_t
        dx = px_abs - hx
        dy = py_abs - hy
        
        grad = -2 * (dx * a * sinh_t + dy * b * cosh_t)
        hess = 2 * (a**2 * sinh_t**2 + b**2 * cosh_t**2 - dx * a * cosh_t - dy * b * sinh_t) + 1e-6
        
        step = grad / torch.abs(hess)
        t = t - torch.clamp(step, -0.3, 0.3)
        t = torch.clamp(t, 0.001, 20.0)
    
    cosh_t = torch.cosh(t)
    sinh_t = torch.sinh(t)
    return torch.sqrt((px_abs - a * cosh_t)**2 + (py_abs - b * sinh_t)**2 + 1e-10)


def ellipse_distance_quartic(px: torch.Tensor, py: torch.Tensor,
                              a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
    """Compute exact distance from point to ellipse using Newton iteration."""
    px_abs = torch.abs(px)
    py_abs = torch.abs(py)
    
    a_use = torch.max(a, b)
    b_use = torch.min(a, b)
    
    needs_swap = a < b
    if needs_swap:
        px_use, py_use = py_abs, px_abs
    else:
        px_use, py_use = px_abs, py_abs
    
    at_origin = (px_use < 1e-10) & (py_use < 1e-10)
    on_x_axis = py_use < 1e-10
    on_y_axis = px_use < 1e-10
    
    theta = torch.atan2(a_use * py_use, b_use * px_use)
    
    for _ in range(12):
        cos_t = torch.cos(theta)
        sin_t = torch.sin(theta)
        ex = a_use * cos_t
        ey = b_use * sin_t
        dx = px_use - ex
        dy = py_use - ey
        
        grad = 2 * (dx * a_use * sin_t - dy * b_use * cos_t)
        hess = 2 * (a_use**2 * sin_t**2 + b_use**2 * cos_t**2 + dx * a_use * cos_t + dy * b_use * sin_t) + 1e-6
        
        theta = theta - torch.clamp(grad / torch.abs(hess), -0.3, 0.3)
    
    cos_t = torch.cos(theta)
    sin_t = torch.sin(theta)
    dist = torch.sqrt((px_use - a_use * cos_t)**2 + (py_use - b_use * sin_t)**2 + 1e-10)
    
    dist = torch.where(at_origin, b_use, dist)
    dist = torch.where(on_x_axis & ~at_origin, torch.where(px_use > a_use, px_use - a_use, torch.sqrt((px_use - a_use)**2 + 1e-10)), dist)
    dist = torch.where(on_y_axis & ~at_origin, torch.abs(py_use - b_use), dist)
    
    return dist


# =============================================================================
# SDF Primitives Base Class
# =============================================================================

class SDFPrimitive(nn.Module):
    """Base class for SDF primitives - all shapes represented as distance functions."""
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        """Compute signed distance from points p to the shape boundary."""
        raise NotImplementedError


class PointSDF(SDFPrimitive):
    """SDF for a point: f(p; c) = ||p - c||₂"""
    
    def __init__(self, center: torch.Tensor):
        super().__init__()
        self.center = nn.Parameter(center.clone())
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        return torch.norm(p - self.center, dim=-1)


class CircleSDF(SDFPrimitive):
    """SDF for circle: f(p; c, r) = ||p - c||₂ - r"""
    
    def __init__(self, center: torch.Tensor, radius: torch.Tensor):
        super().__init__()
        self.center = nn.Parameter(center.clone())
        self.radius = nn.Parameter(radius.clone())
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        dist_to_center = torch.norm(p - self.center, dim=-1)
        return dist_to_center - self.radius


class EllipseSDF(SDFPrimitive):
    """SDF for ellipse: x²/a² + y²/b² = 1"""
    
    def __init__(self, center: torch.Tensor, a: torch.Tensor, b: torch.Tensor):
        super().__init__()
        self.center = nn.Parameter(center.clone())
        self.a = nn.Parameter(a.clone())
        self.b = nn.Parameter(b.clone())
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        p_local = p - self.center
        px = p_local[..., 0]
        py = p_local[..., 1]
        
        a = torch.abs(self.a) + 1e-8
        b = torch.abs(self.b) + 1e-8
        
        dist = ellipse_distance_quartic(px, py, a, b)
        ellipse_val = px**2 / (a**2) + py**2 / (b**2)
        inside = ellipse_val < 1
        
        return torch.where(inside, -dist, dist)


class HyperbolaSDF(SDFPrimitive):
    """SDF for hyperbola: x²/a² - y²/b² = 1"""
    
    def __init__(self, center: torch.Tensor, a: torch.Tensor, b: torch.Tensor):
        super().__init__()
        self.center = nn.Parameter(center.clone())
        self.a = nn.Parameter(a.clone())
        self.b = nn.Parameter(b.clone())
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        p_local = p - self.center
        px = p_local[..., 0]
        py = p_local[..., 1]
        
        a = torch.abs(self.a) + 1e-8
        b = torch.abs(self.b) + 1e-8
        
        dist = hyperbola_distance_quartic(px, py, a, b)
        hyperbola_val = px**2 / (a**2) - py**2 / (b**2)
        is_between_branches = hyperbola_val < 1
        
        return torch.where(is_between_branches, -dist, dist)


class ParabolaSDF(SDFPrimitive):
    """SDF for parabola: y² = 4px (rightward) or x² = 4py (upward)"""
    
    def __init__(self, vertex: torch.Tensor, p: torch.Tensor, direction: str = 'right'):
        super().__init__()
        self.vertex = nn.Parameter(vertex.clone())
        self.p = nn.Parameter(p.clone())
        self.direction = direction
    
    def forward(self, pts: torch.Tensor) -> torch.Tensor:
        p_local = pts - self.vertex
        px = p_local[..., 0]
        py = p_local[..., 1]
        p_param = torch.abs(self.p) + 1e-6
        
        if self.direction == 'right':
            return self._compute_distance_right(px, py, p_param)
        elif self.direction == 'left':
            return self._compute_distance_right(-px, py, p_param)
        elif self.direction == 'up':
            return self._compute_distance_right(py, px, p_param)
        elif self.direction == 'down':
            return self._compute_distance_right(-py, px, p_param)
        return self._compute_distance_right(px, py, p_param)
    
    def _compute_distance_right(self, px: torch.Tensor, py: torch.Tensor, p: torch.Tensor) -> torch.Tensor:
        t = py.clone()
        
        for _ in range(12):
            para_x = t**2 / (4 * p)
            para_y = t
            dx = px - para_x
            dy = py - para_y
            dpara_x = t / (2 * p)
            dpara_y = torch.ones_like(t)
            
            grad = -2 * (dx * dpara_x + dy * dpara_y)
            ddpara_x = 1 / (2 * p)
            hess = 2 * (dpara_x**2 + dpara_y**2 - dx * ddpara_x) + 1e-8
            
            t = t - torch.clamp(grad / torch.abs(hess), -1.0, 1.0)
        
        para_x = t**2 / (4 * p)
        para_y = t
        dist = torch.sqrt((px - para_x)**2 + (py - para_y)**2 + 1e-10)
        
        at_vertex = (torch.abs(px) < 1e-6) & (torch.abs(py) < 1e-6)
        dist = torch.where(at_vertex, torch.zeros_like(dist), dist)
        
        on_concave_side = (px >= 0) & (py**2 < 4 * p * px)
        return torch.where(on_concave_side, -dist, dist)


class LineSDF(SDFPrimitive):
    """SDF for infinite line passing through point with direction."""
    
    def __init__(self, point: torch.Tensor, direction: torch.Tensor):
        super().__init__()
        self.point = nn.Parameter(point.clone())
        self.direction = nn.Parameter(direction / (torch.norm(direction) + 1e-8))
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        v = p - self.point
        normal = torch.tensor([-self.direction[1], self.direction[0]], device=p.device)
        return (v * normal).sum(dim=-1)


class LineSegmentSDF(SDFPrimitive):
    """SDF for line segment from point a to point b."""
    
    def __init__(self, a: torch.Tensor, b: torch.Tensor):
        super().__init__()
        self.a = nn.Parameter(a.clone())
        self.b = nn.Parameter(b.clone())
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        v_ab = self.b - self.a
        v_ap = p - self.a
        h = (v_ap * v_ab).sum(dim=-1) / (torch.norm(v_ab)**2 + 1e-8)
        h_clamped = torch.clamp(h, 0, 1)
        closest = self.a + h_clamped.unsqueeze(-1) * v_ab
        return torch.norm(p - closest, dim=-1)


class TriangleEdgesSDF(SDFPrimitive):
    """SDF for triangle edges (boundary only)."""
    
    def __init__(self, v0: torch.Tensor, v1: torch.Tensor, v2: torch.Tensor, 
                 line_thickness: float = 0.02):
        super().__init__()
        self.edge0 = LineSegmentSDF(v0, v1)
        self.edge1 = LineSegmentSDF(v1, v2)
        self.edge2 = LineSegmentSDF(v2, v0)
        self.thickness = line_thickness
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        d0 = self.edge0(p)
        d1 = self.edge1(p)
        d2 = self.edge2(p)
        return torch.min(torch.min(d0, d1), d2) - self.thickness


class TriangleFillSDF(SDFPrimitive):
    """SDF for filled triangle region."""
    
    def __init__(self, v0: torch.Tensor, v1: torch.Tensor, v2: torch.Tensor):
        super().__init__()
        self.v0 = nn.Parameter(v0.clone())
        self.v1 = nn.Parameter(v1.clone())
        self.v2 = nn.Parameter(v2.clone())
        self.edge0 = LineSegmentSDF(v0, v1)
        self.edge1 = LineSegmentSDF(v1, v2)
        self.edge2 = LineSegmentSDF(v2, v0)
    
    def _sign(self, p: torch.Tensor, a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
        return (p[..., 0] - a[0]) * (b[1] - a[1]) - (b[0] - a[0]) * (p[..., 1] - a[1])
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        d0 = self.edge0(p)
        d1 = self.edge1(p)
        d2 = self.edge2(p)
        dist = torch.min(torch.min(d0, d1), d2)
        
        s0 = self._sign(p, self.v0, self.v1)
        s1 = self._sign(p, self.v1, self.v2)
        s2 = self._sign(p, self.v2, self.v0)
        
        inside = ((s0 >= 0) & (s1 >= 0) & (s2 >= 0)) | ((s0 <= 0) & (s1 <= 0) & (s2 <= 0))
        return torch.where(inside, -dist, dist)


class RightAngleSDF(SDFPrimitive):
    """SDF for right angle marker."""
    
    def __init__(self, vertex: torch.Tensor, dir1: torch.Tensor, dir2: torch.Tensor,
                 size: float = 0.25, thickness: float = 0.015):
        super().__init__()
        dir1_norm = dir1 / (torch.norm(dir1) + 1e-8)
        dir2_norm = dir2 / (torch.norm(dir2) + 1e-8)
        
        p1 = vertex + dir1_norm * size
        p2 = vertex + dir2_norm * size
        p3 = vertex + dir1_norm * size + dir2_norm * size
        
        self.seg1 = LineSegmentSDF(p1, p3)
        self.seg2 = LineSegmentSDF(p2, p3)
        self.thickness = thickness
    
    def forward(self, p: torch.Tensor) -> torch.Tensor:
        return torch.min(self.seg1(p), self.seg2(p)) - self.thickness