from __future__ import annotations

import math
from typing import Iterable

import numpy as np


NUM_JOINTS = 17

COCO_BONES: list[tuple[int, int]] = [
    (0, 1), (0, 2), (1, 3), (2, 4),
    (5, 6), (5, 7), (7, 9), (6, 8), (8, 10),
    (5, 11), (6, 12), (11, 12),
    (11, 13), (13, 15), (12, 14), (14, 16),
]

LOWER_BODY = [11, 12, 13, 14, 15, 16]
UPPER_BODY = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


def normalize_pose(kpts: np.ndarray, eps: float = 1e-6) -> np.ndarray:
    """Normalize COCO keypoints by per-frame visible bounding box."""
    out = np.asarray(kpts, dtype=np.float32).copy()
    xy = out[..., :2]
    conf = out[..., 2]
    for t in range(out.shape[0]):
        valid = conf[t] > 0
        if not np.any(valid):
            out[t, :, :2] = 0
            continue
        pts = xy[t, valid]
        mn = pts.min(axis=0)
        mx = pts.max(axis=0)
        center = (mn + mx) / 2.0
        size = np.maximum(mx - mn, eps)
        out[t, :, 0] = (out[t, :, 0] - center[0]) / size[0]
        out[t, :, 1] = (out[t, :, 1] - center[1]) / size[1]
        out[t, ~valid, :2] = 0
    return out


def resample_or_pad(kpts: np.ndarray, clip_len: int) -> np.ndarray:
    if len(kpts) == clip_len:
        return kpts.astype(np.float32)
    if len(kpts) <= 0:
        return np.zeros((clip_len, NUM_JOINTS, 3), dtype=np.float32)
    if len(kpts) < clip_len:
        pad = np.repeat(kpts[-1:,...], clip_len - len(kpts), axis=0)
        return np.concatenate([kpts, pad], axis=0).astype(np.float32)
    idx = np.linspace(0, len(kpts) - 1, clip_len).round().astype(np.int64)
    return kpts[idx].astype(np.float32)


def make_clips(kpts: np.ndarray, clip_len: int, stride: int) -> list[np.ndarray]:
    if len(kpts) <= clip_len:
        return [resample_or_pad(kpts, clip_len)]
    clips = []
    for start in range(0, len(kpts) - clip_len + 1, stride):
        clips.append(kpts[start:start + clip_len].astype(np.float32))
    if not clips:
        clips.append(resample_or_pad(kpts, clip_len))
    return clips


def bone_features(joint: np.ndarray) -> np.ndarray:
    bone = np.zeros_like(joint, dtype=np.float32)
    for parent, child in COCO_BONES:
        bone[:, child, :2] = joint[:, child, :2] - joint[:, parent, :2]
        bone[:, child, 2] = np.minimum(joint[:, child, 2], joint[:, parent, 2])
    return bone


def temporal_diff(x: np.ndarray) -> np.ndarray:
    diff = np.zeros_like(x, dtype=np.float32)
    diff[1:] = x[1:] - x[:-1]
    return diff


def dynamics_features(joint: np.ndarray) -> np.ndarray:
    xy = joint[..., :2]
    conf = joint[..., 2:3]
    vel = temporal_diff(xy)
    acc = temporal_diff(vel)
    center = weighted_center(xy, conf)
    center_vel = temporal_diff(center)
    torso = torso_angle(xy)
    hip = xy[:, [11, 12], 1].mean(axis=1, keepdims=True)
    hip_drop = temporal_diff(hip)
    aspect = body_aspect_ratio(xy, conf)
    global_dyn = np.concatenate([center_vel, torso, hip_drop, aspect], axis=1)
    global_dyn = np.repeat(global_dyn[:, None, :], NUM_JOINTS, axis=1)
    return np.concatenate([vel, acc, global_dyn], axis=2).astype(np.float32)


def weighted_center(xy: np.ndarray, conf: np.ndarray, eps: float = 1e-6) -> np.ndarray:
    w = np.clip(conf, 0.0, 1.0)
    return (xy * w).sum(axis=1) / (w.sum(axis=1) + eps)


def torso_angle(xy: np.ndarray) -> np.ndarray:
    shoulder = xy[:, [5, 6]].mean(axis=1)
    hip = xy[:, [11, 12]].mean(axis=1)
    vec = shoulder - hip
    angle = np.arctan2(vec[:, 1], vec[:, 0]) / math.pi
    return angle[:, None].astype(np.float32)


def body_aspect_ratio(xy: np.ndarray, conf: np.ndarray, eps: float = 1e-6) -> np.ndarray:
    ratios = []
    visible = conf[..., 0] > 0
    for t in range(xy.shape[0]):
        if not np.any(visible[t]):
            ratios.append([0.0])
            continue
        pts = xy[t, visible[t]]
        wh = pts.max(axis=0) - pts.min(axis=0)
        ratios.append([float(wh[1] / (wh[0] + eps))])
    return np.asarray(ratios, dtype=np.float32)


def mask_keypoints(
    joint: np.ndarray,
    mode: str,
    amount: float = 0.0,
    rng: np.random.Generator | None = None,
) -> np.ndarray:
    rng = rng or np.random.default_rng()
    out = joint.copy()
    if mode == "clean":
        return out
    if mode.startswith("missing"):
        prob = amount
        mask = rng.random(out.shape[:2]) < prob
        out[mask] = 0
    elif mode == "lower_body":
        out[:, LOWER_BODY] = 0
    elif mode == "upper_body":
        out[:, UPPER_BODY] = 0
    elif mode == "low_conf":
        out[out[..., 2] < 0.5] = 0
    else:
        raise ValueError(f"Unknown robustness mode: {mode}")
    return out.astype(np.float32)


def infer_label_from_path(path: str) -> int:
    parts = [p.lower() for p in path.replace("\\", "/").split("/")]
    positives = {"fall", "falls", "fallen", "positive", "1"}
    return int(any(p in positives for p in parts))