"""
Geometric Constraints - Differentiable constraint functions for optimization.
Following GeoSDF paper Section 5.
"""

import torch
from typing import Callable


class GeometricConstraints:
    """Collection of differentiable geometric constraint functions."""
    
    @staticmethod
    def point_on_curve(sdf: Callable, point: torch.Tensor) -> torch.Tensor:
        """Constraint: point lies on curve (SDF = 0)."""
        return sdf(point.unsqueeze(0))**2
    
    @staticmethod
    def distance_constraint(p1: torch.Tensor, p2: torch.Tensor, 
                           target_dist: float) -> torch.Tensor:
        """Constraint: distance between two points equals target."""
        actual_dist = torch.norm(p1 - p2)
        return (actual_dist - target_dist)**2
    
    @staticmethod
    def eccentricity_ellipse(a: torch.Tensor, b: torch.Tensor, 
                            target_e: float) -> torch.Tensor:
        """Constraint: ellipse eccentricity."""
        c_squared = a**2 - b**2
        c = torch.sqrt(torch.clamp(c_squared, min=1e-8))
        e = c / a
        return (e - target_e)**2
    
    @staticmethod
    def eccentricity_hyperbola(a: torch.Tensor, b: torch.Tensor,
                               target_e: float) -> torch.Tensor:
        """Constraint: hyperbola eccentricity e = c/a where c² = a² + b²."""
        c_squared = a**2 + b**2
        c = torch.sqrt(c_squared)
        e = c / (a + 1e-8)
        return (e - target_e)**2
    
    @staticmethod
    def asymptote_slope(a: torch.Tensor, b: torch.Tensor, 
                       target_slope: float) -> torch.Tensor:
        """Constraint: hyperbola asymptote slope b/a."""
        actual_slope = b / (a + 1e-8)
        return (actual_slope - target_slope)**2
    
    @staticmethod
    def focus_constraint(a: torch.Tensor, b: torch.Tensor, 
                        focus_coord: float, is_hyperbola: bool = False) -> torch.Tensor:
        """Constraint: focus at specific coordinate."""
        if is_hyperbola:
            c_squared = a**2 + b**2
        else:
            c_squared = a**2 - b**2
        c = torch.sqrt(torch.clamp(c_squared, min=1e-8))
        return (c - abs(focus_coord))**2
    
    @staticmethod
    def focus_constraint_hyperbola(a: torch.Tensor, b: torch.Tensor, 
                                   target_c: float) -> torch.Tensor:
        """Constraint: hyperbola focus distance c where c² = a² + b²."""
        c_squared = a**2 + b**2
        c = torch.sqrt(c_squared)
        return (c - target_c)**2
    
    @staticmethod
    def positive_constraint(param: torch.Tensor, min_val: float = 0.1) -> torch.Tensor:
        """Soft constraint to keep parameter positive."""
        return torch.relu(min_val - param)**2
    
    @staticmethod
    def crowd_penalty(positions: list, min_dist: float = 0.5) -> torch.Tensor:
        """Penalty for elements being too close together."""
        penalty = torch.tensor(0.0)
        for i, p1 in enumerate(positions):
            for p2 in positions[i+1:]:
                dist = torch.norm(p1 - p2)
                penalty = penalty + torch.relu(min_dist - dist)**2
        return penalty