"""Rest attitude for a reconstructed SAM3D object on a Z-up table.

The generated URDF applies no ``rpy``, so identity in Isaac Lab lays the object on
its side. The clip quaternion has the right attitude but is tilted a few degrees,
which is enough to roll a box. Snap that tilt out, keep the clip's yaw and its
resting face, and sit the origin on the lowest vertex.
"""

from __future__ import annotations

import re
from pathlib import Path

import numpy as np

from .math_np import quat_mul_wxyz, quat_rotate

_MESH_RE = re.compile(
    r'filename="([^"]+\.obj)".*?scale="([0-9.eE+-]+)',
    re.IGNORECASE | re.DOTALL,
)


def urdf_mesh(urdf: str | Path) -> tuple[Path, float] | None:
    path = Path(urdf)
    if not path.is_file():
        return None
    text = path.read_text()
    m = _MESH_RE.search(text)
    if m is None:
        return None
    mesh = (path.parent / m.group(1)).resolve()
    if not mesh.is_file():
        return None
    return mesh, float(m.group(2))


def load_obj_verts(mesh: Path, scale: float) -> np.ndarray:
    verts: list[list[float]] = []
    with mesh.open() as f:
        for line in f:
            if line.startswith("v "):
                verts.append([float(x) for x in line.split()[1:4]])
    if not verts:
        raise RuntimeError(f"no vertices in {mesh}")
    return np.asarray(verts, dtype=np.float64) * float(scale)


def _quat_align_wxyz(src: np.ndarray, dst: np.ndarray) -> np.ndarray:
    """Shortest rotation taking ``src`` onto ``dst`` (wxyz)."""
    a = np.asarray(src, dtype=np.float64)
    b = np.asarray(dst, dtype=np.float64)
    a = a / (np.linalg.norm(a) + 1e-12)
    b = b / (np.linalg.norm(b) + 1e-12)
    ax = np.cross(a, b)
    s = float(np.linalg.norm(ax))
    c = float(np.dot(a, b))
    if s < 1e-9:
        return np.array([1.0, 0.0, 0.0, 0.0] if c > 0.0 else [0.0, 1.0, 0.0, 0.0])
    ax = ax / s
    half = 0.5 * np.arctan2(s, c)
    return np.concatenate([[np.cos(half)], ax * np.sin(half)])


#: The six signed body axes, candidates for the one the object rests on.
_BODY_AXES = np.vstack([np.eye(3), -np.eye(3)])


def upright_body_axis(clip_wxyz: np.ndarray) -> np.ndarray:
    """The body axis the clip already points most nearly upward.

    Which way a SAM3D mesh is "up" is not a fixed convention: the coffee can rests
    on body +Y, the sugar box on -Y. Reading it off the demonstration avoids
    assuming, and avoids standing an object on a face the human never rested it on.
    """
    q = np.asarray(clip_wxyz, dtype=np.float64)
    q = q / (np.linalg.norm(q) + 1e-12)
    world = quat_rotate(np.tile(q, (len(_BODY_AXES), 1)), _BODY_AXES)
    return _BODY_AXES[int(np.argmax(world[:, 2]))]


def flatten_upright_wxyz(
    clip_wxyz: np.ndarray,
    up_axis: np.ndarray | None = None,
) -> np.ndarray:
    """Drop the clip's residual tilt, keeping its yaw and its resting face.

    A few degrees of tilt is enough to roll a box, so the axis nearest vertical is
    snapped exactly to world +Z. ``up_axis`` defaults to :func:`upright_body_axis`.
    """
    q = np.asarray(clip_wxyz, dtype=np.float64)
    q = q / (np.linalg.norm(q) + 1e-12)
    axis = upright_body_axis(q) if up_axis is None else np.asarray(up_axis, dtype=np.float64)
    up_w = quat_rotate(q, axis)
    return quat_mul_wxyz(_quat_align_wxyz(up_w, np.array([0.0, 0.0, 1.0])), q)


def demo_rest_wxyz(urdf: str | Path) -> np.ndarray | None:
    """Object attitude at the moment it sits lowest in the clip, i.e. on the table.

    Frame 0 is not reliable: some clips open with the object already lifted.
    """
    replay = Path(urdf).resolve().parent.parent / "isaaclab_replay.npz"
    if not replay.is_file():
        return None
    data = np.load(replay, allow_pickle=True)
    if "object_wxyz" not in data or "object_pos" not in data:
        return None
    pos, quat = data["object_pos"], data["object_wxyz"]
    if len(pos) == 0:
        return None
    return np.asarray(quat[int(np.argmin(pos[:, 2]))], dtype=np.float64)


def support_height(verts: np.ndarray, wxyz: np.ndarray) -> float:
    vr = quat_rotate(np.tile(np.asarray(wxyz, dtype=np.float64), (len(verts), 1)), verts)
    return float(-vr[:, 2].min())


def rest_pose(
    urdf: str | Path,
    clip_wxyz: np.ndarray,
) -> tuple[np.ndarray, float] | None:
    """``(wxyz, origin height above table)`` for a firm rest, or None if no mesh."""
    parsed = urdf_mesh(urdf)
    if parsed is None:
        return None
    mesh, scale = parsed
    verts = load_obj_verts(mesh, scale)
    q = flatten_upright_wxyz(clip_wxyz)
    return q, support_height(verts, q)