#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from pathlib import Path

import cv2
import numpy as np
from tqdm import tqdm


# =========================
# Parameters
# =========================
DATAMAKER_DIR = Path(__file__).resolve().parent

INPUT_DIR = DATAMAKER_DIR / "01_align"
MATRIX_DIR = DATAMAKER_DIR / "matrix"
OUTPUT_DIR = DATAMAKER_DIR / "02_warp"

VIDEO_IDS = [f"{idx:02d}" for idx in range(1, 15)]
TARGET_WIDTH = 1280
TARGET_HEIGHT = 1024
OFFSET_WIDTH = -40
OFFSET_HEIGHT = 0
MATRIX_TRANSPOSE = True
INTERPOLATION = cv2.INTER_CUBIC
FOURCC = "mp4v"
OVERWRITE = True
# =========================


def load_matrix(matrix_path: Path) -> np.ndarray:
    if not matrix_path.exists():
        raise FileNotFoundError(f"Matrix not found: {matrix_path}")

    matrix = np.genfromtxt(matrix_path, delimiter=",")
    if matrix.shape != (3, 3):
        raise ValueError(f"Matrix must be 3x3: {matrix_path}")
    return matrix.T if MATRIX_TRANSPOSE else matrix


def get_crop_region(frame_shape: tuple[int, ...]) -> tuple[int, int]:
    height, width = frame_shape[:2]
    height_start = int((height - TARGET_HEIGHT) / 2) + OFFSET_HEIGHT
    width_start = int((width - TARGET_WIDTH) / 2) + OFFSET_WIDTH

    if (
        height_start < 0
        or width_start < 0
        or height_start + TARGET_HEIGHT > height
        or width_start + TARGET_WIDTH > width
    ):
        raise ValueError(
            "Crop region is out of bounds. "
            f"frame=({width}x{height}), crop=({TARGET_WIDTH}x{TARGET_HEIGHT}), "
            f"start=({width_start},{height_start})"
        )
    return height_start, width_start


def warp_pair(
    ir_path: Path,
    vi_path: Path,
    matrix_path: Path,
    out_ir_path: Path,
    out_vi_path: Path,
) -> None:
    if not ir_path.exists() or not vi_path.exists():
        raise FileNotFoundError(f"Missing input pair: {ir_path}, {vi_path}")
    if not OVERWRITE and (out_ir_path.exists() or out_vi_path.exists()):
        raise FileExistsError(
            f"Output exists and OVERWRITE=False: {out_ir_path}, {out_vi_path}"
        )

    matrix = load_matrix(matrix_path)
    cap_ir = cv2.VideoCapture(str(ir_path))
    cap_vi = cv2.VideoCapture(str(vi_path))
    if not cap_ir.isOpened() or not cap_vi.isOpened():
        raise IOError(f"Failed to open videos: {ir_path}, {vi_path}")

    ok_first_vi, first_vi = cap_vi.read()
    if not ok_first_vi:
        raise IOError(f"Failed to read first VI frame: {vi_path}")
    vi_height, vi_width = first_vi.shape[:2]
    height_start, width_start = get_crop_region(first_vi.shape)

    out_ir_path.parent.mkdir(parents=True, exist_ok=True)
    out_vi_path.parent.mkdir(parents=True, exist_ok=True)

    fps = cap_vi.get(cv2.CAP_PROP_FPS)
    fourcc = cv2.VideoWriter_fourcc(*FOURCC)
    out_ir = cv2.VideoWriter(
        str(out_ir_path), fourcc, fps, (TARGET_WIDTH, TARGET_HEIGHT), False
    )
    out_vi = cv2.VideoWriter(
        str(out_vi_path), fourcc, fps, (TARGET_WIDTH, TARGET_HEIGHT), True
    )
    if not out_ir.isOpened() or not out_vi.isOpened():
        raise IOError(f"Failed to open output writers: {out_ir_path}, {out_vi_path}")

    total_frames = min(
        int(cap_ir.get(cv2.CAP_PROP_FRAME_COUNT)),
        int(cap_vi.get(cv2.CAP_PROP_FRAME_COUNT)),
    )
    cap_vi.set(cv2.CAP_PROP_POS_FRAMES, 0)

    for _ in tqdm(
        range(total_frames),
        desc=f"Warp {ir_path.parent.name}",
        unit="frame",
        position=1,
        leave=False,
    ):
        ok_ir, frame_ir = cap_ir.read()
        ok_vi, frame_vi = cap_vi.read()
        if not ok_ir or not ok_vi:
            break

        if len(frame_ir.shape) == 3:
            frame_ir = cv2.cvtColor(frame_ir, cv2.COLOR_BGR2GRAY)

        ir_warp = cv2.warpPerspective(
            frame_ir,
            matrix,
            (vi_width, vi_height),
            flags=INTERPOLATION,
        )
        ir_output = ir_warp[
            height_start : height_start + TARGET_HEIGHT,
            width_start : width_start + TARGET_WIDTH,
        ]
        vi_output = frame_vi[
            height_start : height_start + TARGET_HEIGHT,
            width_start : width_start + TARGET_WIDTH,
        ]

        out_ir.write(ir_output)
        out_vi.write(vi_output)

    cap_ir.release()
    cap_vi.release()
    out_ir.release()
    out_vi.release()


def main() -> None:
    with tqdm(
        total=len(VIDEO_IDS),
        desc="Total warp",
        unit="video",
        position=0,
    ) as progress:
        for video_id in VIDEO_IDS:
            progress.set_postfix(video=video_id)
            out_dir = OUTPUT_DIR / video_id
            warp_pair(
                ir_path=INPUT_DIR / video_id / "ir.mp4",
                vi_path=INPUT_DIR / video_id / "vi.mp4",
                matrix_path=MATRIX_DIR / f"{video_id}.csv",
                out_ir_path=out_dir / "ir.mp4",
                out_vi_path=out_dir / "vi.mp4",
            )
            tqdm.write(f"Warped {video_id} -> {out_dir}")
            progress.update(1)


if __name__ == "__main__":
    main()