"""Extract two persistent COCO-17 dancer tracks from the local reference clip.

The copyrighted source video and source-overlay QA video remain local. The
JSONL/NPZ annotations and skeleton-only visualizations are publishable derived
research artifacts.
"""

from __future__ import annotations

import argparse
import hashlib
from itertools import permutations
import json
from pathlib import Path

import cv2
import numpy as np
from ultralytics import YOLO


JOINT_NAMES = (
    "nose", "left_eye", "right_eye", "left_ear", "right_ear",
    "left_shoulder", "right_shoulder", "left_elbow", "right_elbow",
    "left_wrist", "right_wrist", "left_hip", "right_hip", "left_knee",
    "right_knee", "left_ankle", "right_ankle",
)
SKELETON_EDGES = (
    (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),
)
TRACK_NAMES = ("locomotion_left_dancer", "expression_right_dancer")
TRACK_COLORS = ((40, 220, 250), (238, 82, 170))


def sha256_file(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as source:
        for block in iter(lambda: source.read(1024 * 1024), b""):
            digest.update(block)
    return digest.hexdigest()


def choose_candidates(result, frame_width: int, frame_height: int) -> list[dict]:
    if result.boxes is None or result.keypoints is None:
        return []
    boxes = result.boxes.xyxy.detach().cpu().numpy()
    scores = result.boxes.conf.detach().cpu().numpy()
    keypoints = result.keypoints.data.detach().cpu().numpy()
    candidates = []
    for box, score, joints in zip(boxes, scores, keypoints, strict=True):
        x1, y1, x2, y2 = (float(value) for value in box)
        width = max(0.0, x2 - x1)
        height = max(0.0, y2 - y1)
        if height < frame_height * 0.35 or width < frame_width * 0.04:
            continue
        candidates.append({
            "box": np.array((x1, y1, x2, y2), dtype=np.float32),
            "score": float(score),
            "keypoints": joints.astype(np.float32),
            "center": np.array(((x1 + x2) * 0.5, (y1 + y2) * 0.5), dtype=np.float32),
            "quality": float(score * np.sqrt(width * height)),
        })
    candidates.sort(key=lambda item: item["quality"], reverse=True)
    return candidates[:4]


def assign_tracks(candidates: list[dict], previous: np.ndarray | None) -> list[dict | None]:
    if len(candidates) < 2:
        return [None, None]
    if previous is None or not np.isfinite(previous).all():
        return sorted(candidates[:2], key=lambda item: float(item["center"][0]))
    best_cost = np.inf
    best = None
    for assignment in permutations(range(len(candidates)), 2):
        centers = np.stack([candidates[index]["center"] for index in assignment])
        cost = float(np.linalg.norm(centers - previous, axis=1).sum())
        if centers[0, 0] > centers[1, 0]:
            cost += 0.35 * abs(float(centers[0, 0] - centers[1, 0]))
        if cost < best_cost:
            best_cost = cost
            best = assignment
    assert best is not None
    return [candidates[best[0]], candidates[best[1]]]


def draw_skeleton(
    image: np.ndarray,
    joints: np.ndarray,
    color: tuple[int, int, int],
    scale_xy: tuple[float, float] = (1.0, 1.0),
) -> None:
    sx, sy = scale_xy

    def point(index: int) -> tuple[int, int]:
        return (int(round(float(joints[index, 0]) * sx)), int(round(float(joints[index, 1]) * sy)))

    for start, end in SKELETON_EDGES:
        if joints[start, 2] >= 0.25 and joints[end, 2] >= 0.25:
            cv2.line(image, point(start), point(end), color, 4, cv2.LINE_AA)
    for index in range(len(JOINT_NAMES)):
        if joints[index, 2] >= 0.25:
            cv2.circle(image, point(index), 6, (255, 255, 255), -1, cv2.LINE_AA)
            cv2.circle(image, point(index), 4, color, -1, cv2.LINE_AA)


def serialize_track(track: np.ndarray, box: np.ndarray, frame_width: int, frame_height: int) -> dict:
    return {
        "bbox_xyxy_px": [round(float(value), 3) for value in box],
        "joints": {
            name: {
                "x_px": round(float(track[index, 0]), 3),
                "y_px": round(float(track[index, 1]), 3),
                "x_norm": round(float(track[index, 0] / frame_width), 7),
                "y_norm": round(float(track[index, 1] / frame_height), 7),
                "confidence": round(float(track[index, 2]), 6),
            }
            for index, name in enumerate(JOINT_NAMES)
        },
    }


def run(args: argparse.Namespace) -> dict:
    video_path = args.video.resolve()
    output_dir = args.output.resolve()
    qa_dir = output_dir / "qa"
    examples_dir = output_dir / "examples"
    output_dir.mkdir(parents=True, exist_ok=True)
    qa_dir.mkdir(parents=True, exist_ok=True)
    examples_dir.mkdir(parents=True, exist_ok=True)

    capture = cv2.VideoCapture(str(video_path))
    if not capture.isOpened():
        raise RuntimeError(f"Could not open {video_path}")
    fps = float(capture.get(cv2.CAP_PROP_FPS))
    frame_count = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))
    width = int(capture.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(capture.get(cv2.CAP_PROP_FRAME_HEIGHT))
    if fps <= 0 or frame_count <= 0 or width <= 0 or height <= 0:
        raise RuntimeError("Invalid video metadata")

    model = YOLO(args.model)
    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
    overlay_path = qa_dir / "source_pose_overlay.mp4"
    skeleton_path = examples_dir / "skeleton_only.mp4"
    overlay_writer = cv2.VideoWriter(str(overlay_path), fourcc, fps, (width, height))
    skeleton_size = (960, 540)
    skeleton_writer = cv2.VideoWriter(str(skeleton_path), fourcc, fps, skeleton_size)
    if not overlay_writer.isOpened() or not skeleton_writer.isOpened():
        raise RuntimeError("Could not create QA video writers")

    all_keypoints = np.full((frame_count, 2, len(JOINT_NAMES), 3), np.nan, dtype=np.float32)
    all_boxes = np.full((frame_count, 2, 4), np.nan, dtype=np.float32)
    all_scores = np.full((frame_count, 2), np.nan, dtype=np.float32)
    valid = np.zeros((frame_count, 2), dtype=bool)
    previous_centers = None
    example_indices = set(np.linspace(0, frame_count - 1, 8, dtype=int).tolist())
    records_path = output_dir / "human_pose_coco17.jsonl"

    with records_path.open("w", encoding="utf-8") as records:
        for frame_index in range(frame_count):
            ok, frame = capture.read()
            if not ok:
                all_keypoints = all_keypoints[:frame_index]
                all_boxes = all_boxes[:frame_index]
                all_scores = all_scores[:frame_index]
                valid = valid[:frame_index]
                frame_count = frame_index
                break
            result = model.predict(
                frame,
                imgsz=args.image_size,
                conf=args.confidence,
                device=args.device,
                verbose=False,
            )[0]
            tracks = assign_tracks(choose_candidates(result, width, height), previous_centers)
            current_centers = np.full((2, 2), np.nan, dtype=np.float32)
            record = {"frame_index": frame_index, "time_seconds": round(frame_index / fps, 7), "tracks": {}}
            overlay = frame.copy()
            skeleton = np.full((skeleton_size[1], skeleton_size[0], 3), (248, 249, 252), dtype=np.uint8)
            for track_index, track in enumerate(tracks):
                if track is None:
                    continue
                joints = track["keypoints"]
                all_keypoints[frame_index, track_index] = joints
                all_boxes[frame_index, track_index] = track["box"]
                all_scores[frame_index, track_index] = track["score"]
                valid[frame_index, track_index] = True
                current_centers[track_index] = track["center"]
                color = TRACK_COLORS[track_index]
                draw_skeleton(overlay, joints, color)
                x1, y1, x2, y2 = (int(round(float(value))) for value in track["box"])
                cv2.rectangle(overlay, (x1, y1), (x2, y2), color, 3)
                cv2.putText(overlay, TRACK_NAMES[track_index], (x1, max(28, y1 - 12)), cv2.FONT_HERSHEY_SIMPLEX, 0.75, color, 2, cv2.LINE_AA)
                draw_skeleton(skeleton, joints, color, (skeleton_size[0] / width, skeleton_size[1] / height))
                record["tracks"][TRACK_NAMES[track_index]] = serialize_track(joints, track["box"], width, height)
            if np.isfinite(current_centers).all():
                previous_centers = current_centers
            cv2.putText(skeleton, f"t={frame_index / fps:05.2f}s  source-derived skeletons only", (24, 38), cv2.FONT_HERSHEY_SIMPLEX, 0.75, (45, 51, 65), 2, cv2.LINE_AA)
            records.write(json.dumps(record, separators=(",", ":")) + "\n")
            overlay_writer.write(overlay)
            skeleton_writer.write(skeleton)
            if frame_index in example_indices:
                cv2.imwrite(str(examples_dir / f"skeleton_{frame_index:04d}.png"), skeleton)

    capture.release()
    overlay_writer.release()
    skeleton_writer.release()
    np.savez_compressed(
        output_dir / "human_pose_coco17.npz",
        keypoints_xyc=all_keypoints,
        bbox_xyxy=all_boxes,
        detector_confidence=all_scores,
        valid=valid,
        fps=np.array(fps),
        frame_width=np.array(width),
        frame_height=np.array(height),
        joint_names=np.array(JOINT_NAMES),
        track_names=np.array(TRACK_NAMES),
    )
    detection_rate = valid.mean(axis=0)
    mean_joint_confidence = np.nanmean(all_keypoints[..., 2], axis=(0, 2))
    summary = {
        "schema_version": "1.0",
        "source": {
            "youtube_url": "https://www.youtube.com/watch?v=dv2qKpna3lM",
            "clip_start_source_seconds": 103.0,
            "clip_end_source_seconds": 142.0,
            "source_file_sha256": sha256_file(video_path),
            "source_video_included_in_dataset": False,
        },
        "video": {"frame_count": int(frame_count), "fps": fps, "duration_seconds": frame_count / fps, "width": width, "height": height},
        "extractor": {"model": args.model, "image_size": args.image_size, "confidence_threshold": args.confidence, "device": args.device, "joint_schema": "COCO-17"},
        "tracks": {
            TRACK_NAMES[index]: {"detection_rate": float(detection_rate[index]), "mean_joint_confidence": float(mean_joint_confidence[index])}
            for index in range(2)
        },
        "files": {"jsonl": records_path.name, "npz": "human_pose_coco17.npz", "local_source_overlay": str(overlay_path.relative_to(output_dir)), "publishable_skeleton_video": str(skeleton_path.relative_to(output_dir))},
    }
    (output_dir / "extraction_summary.json").write_text(json.dumps(summary, indent=2), encoding="utf-8")
    print(json.dumps(summary, indent=2))
    return summary


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("video", type=Path)
    parser.add_argument("--output", type=Path, required=True)
    parser.add_argument("--model", default="yolo11n-pose.pt")
    parser.add_argument("--image-size", type=int, default=768)
    parser.add_argument("--confidence", type=float, default=0.25)
    parser.add_argument("--device", default="cpu")
    run(parser.parse_args())


if __name__ == "__main__":
    main()