"""
Core Poincaré Ball Operations.

All ops run in fp32 via @_fp32 decorator regardless of ambient mixed-precision.
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
import functools

MIN_NORM = 1e-15
BALL_EPS = 1e-5
TANH_CLAMP = 15.0


def _fp32(fn):
    """Disable autocast, cast inputs to fp32, cast output back."""
    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        with torch.amp.autocast(device_type="cuda", enabled=False):
            orig = None
            for a in args:
                if torch.is_tensor(a):
                    orig = a.dtype; break
            if orig is None:
                for v in kwargs.values():
                    if torch.is_tensor(v):
                        orig = v.dtype; break
            orig = orig or torch.float32
            a32 = [a.float() if torch.is_tensor(a) else a for a in args]
            k32 = {k: v.float() if torch.is_tensor(v) else v for k, v in kwargs.items()}
            r = fn(*a32, **k32)
            return r.to(orig) if torch.is_tensor(r) else r
    return wrapper


def safe_arctanh(x):
    return torch.atanh(x.clamp(-1 + 1e-7, 1 - 1e-7))

def safe_tanh(x):
    return torch.tanh(x.clamp(-TANH_CLAMP, TANH_CLAMP))

def clamp_norm(x, c, eps=BALL_EPS):
    max_norm = (1.0 / torch.sqrt(c)) - eps
    norm = x.norm(dim=-1, keepdim=True).clamp(min=MIN_NORM)
    return torch.where(norm > max_norm, x / norm * max_norm, x)


@_fp32
def exp_map_zero(v, c):
    """Tangent space → Poincaré ball at origin."""
    sqrt_c = torch.sqrt(c)
    v_norm = v.norm(dim=-1, keepdim=True).clamp(min=MIN_NORM)
    factor = safe_tanh(sqrt_c * v_norm) / sqrt_c
    return clamp_norm(factor * (v / v_norm), c)


@_fp32
def log_map_zero(x, c):
    """Poincaré ball → tangent space at origin."""
    sqrt_c = torch.sqrt(c)
    x_norm = x.norm(dim=-1, keepdim=True).clamp(min=MIN_NORM)
    factor = safe_arctanh(sqrt_c * x_norm) / (sqrt_c * x_norm)
    return factor * x


@_fp32
def mobius_add(u, v, c):
    """Möbius addition u ⊕_c v."""
    u2 = (u * u).sum(-1, keepdim=True)
    v2 = (v * v).sum(-1, keepdim=True)
    uv = (u * v).sum(-1, keepdim=True)
    num = (1 + 2 * c * uv + c * v2) * u + (1 - c * u2) * v
    den = (1 + 2 * c * uv + c * c * u2 * v2).clamp(min=MIN_NORM)
    return num / den


@_fp32
def hyperbolic_distance(x, y, c):
    """d_c(x, y) in Poincaré ball."""
    sqrt_c = torch.sqrt(c)
    diff = mobius_add(-x, y, c)
    return (2.0 / sqrt_c) * safe_arctanh(sqrt_c * diff.norm(dim=-1).clamp(min=MIN_NORM))


@_fp32
def poincare_radius(x, c):
    """d_c(0, x) = (2/√c) · artanh(√c · ‖x‖)."""
    sqrt_c = torch.sqrt(c)
    return (2.0 / sqrt_c) * safe_arctanh(sqrt_c * x.norm(dim=-1).clamp(min=MIN_NORM))


@_fp32
def einstein_midpoint(points, weights, c):
    """Weighted Einstein midpoint. points: (..., N, d), weights: (..., N)."""
    p2 = (points * points).sum(-1, keepdim=True)
    klein = 2.0 * points / (1.0 + c * p2).clamp(min=MIN_NORM)
    k2 = (klein * klein).sum(-1, keepdim=True)
    gamma = 1.0 / torch.sqrt((1.0 - c * k2).clamp(min=MIN_NORM))
    w = weights.unsqueeze(-1)
    wg = w * gamma
    k_bar = (wg * klein).sum(-2) / wg.sum(-2).clamp(min=MIN_NORM)
    kb2 = (k_bar * k_bar).sum(-1, keepdim=True)
    denom = 1.0 + torch.sqrt((1.0 - c * kb2).clamp(min=MIN_NORM))
    return clamp_norm(k_bar / denom.clamp(min=MIN_NORM), c)


class LearnableCurvature(nn.Module):
    """c = clamp(softplus(hat_c) + c_min, max=c_max)."""
    def __init__(self, init_value=1.0, c_min=0.01, c_max=None):
        super().__init__()
        self.c_min = c_min
        self.c_max = c_max
        delta = init_value - c_min
        assert delta > 0, f"init_value({init_value}) must > c_min({c_min})"
        if delta > 20.0:
            init_hat = torch.tensor(delta, dtype=torch.float32)
        else:
            init_hat = torch.log(torch.expm1(torch.tensor(delta, dtype=torch.float32)))
        self.hat_c = nn.Parameter(init_hat)

    def forward(self):
        c = F.softplus(self.hat_c) + self.c_min
        if self.c_max is not None:
            c = c.clamp(max=self.c_max)
        return c