"""
render_smal_multiview.py — combine pose + shape + texture into multi-view SMAL dog renders.

Inputs (the released library):
  --pose_npz     library/poses/poses.npz     : pose_6d (N, 34, 6)
  --shape_npz    library/shapes/shapes.npz   : beta (S,30), betas_limbs (S,9), pose_6d (S,34,6),
                                               logscale_part_list (9,)
  --texture_dir  library/textures/           : texture_*.png (2048^2) + uv_atlas_0.pth
                                               [+ uv_atlas_1.pth] + uv_atlas_index.npy
  --bite_root    BITE checkout (code + SMAL weights), see scripts/setup.sh

For each pose, each of the 60 views independently samples a random shape and texture (matching the
released dataset's generation). The shape-specific ear pose (shape pose_6d, joints 32/33) is blended
into the motion pose; cameras orbit the subject (4 azimuth x 5 elevation x 3 roll = 60 views).

Outputs per pose: pose_{idx:06d}/{rgb,seg,npz,...}/{view}.{png,npz}. With --shard (default on,
single process) the per-pose dirs are packed into stored tar shards.

Requires a one-time setup of the SMAL/BITE dependency:  bash scripts/setup.sh
"""
import os
import sys

# Resolve --bite_root early so smal_utils picks it up at import time.
def _early_arg(flag):
    for i, a in enumerate(sys.argv):
        if a == flag and i + 1 < len(sys.argv):
            return sys.argv[i + 1]
        if a.startswith(flag + "="):
            return a.split("=", 1)[1]
    return None

_br = _early_arg("--bite_root")
if _br:
    os.environ["BITE_ROOT"] = _br
os.environ.setdefault("PYOPENGL_PLATFORM", "egl")

import argparse
import random
import numpy as np
import torch
import torch.nn.functional as F
import cv2
from pathlib import Path
from PIL import Image
from str2bool import str2bool

from render_utils import (
    deduce_weak_perspective_params,
    MeshRenderer,
    project_keypoints_to_2d,
    draw_keypoints_on_image,
)
from smal_utils import initialize_smal_model_batch
import shard_utils

# Ear joint indices in the 34-joint pose representation (left_ear, right_ear).
EAR_JOINT_INDICES = [32, 33]


def apply_horizontal_flip_(pose_6d, device):
    assert pose_6d is not None
    assert pose_6d.ndim == 3 and pose_6d.shape[1] == 34 and pose_6d.shape[2] == 6, f"pose_6d.shape: {pose_6d.shape}"
    assert device is not None

    left_indices = [6, 7, 8, 9, 16, 17, 18, 19, 32]
    right_indices = [10, 11, 12, 13, 20, 21, 22, 23, 33]

    pose_6d_flipped = pose_6d.clone()
    pose_6d_flipped[:, left_indices] = pose_6d[:, right_indices].clone()
    pose_6d_flipped[:, right_indices] = pose_6d[:, left_indices].clone()
    pose_6d_flipped[:, :, 1] *= -1
    pose_6d_flipped[:, :, 2] *= -1
    pose_6d_flipped[:, :, 5] *= -1

    N, J, D = pose_6d.shape
    pose_6d_flipped = F.normalize(pose_6d_flipped.reshape(N, J, 3, 2), dim=-2).reshape(N, J, D)
    return pose_6d_flipped


def rotate_rotmat(rotmat, angle_x=0.0, angle_y=0.0, angle_z=0.0, degrees=True):
    """Apply additional rotation to existing rotation matrices."""
    device = rotmat.device
    dtype = rotmat.dtype
    if degrees:
        angle_x = torch.tensor(angle_x, device=device, dtype=dtype) * (torch.pi / 180.0)
        angle_y = torch.tensor(angle_y, device=device, dtype=dtype) * (torch.pi / 180.0)
        angle_z = torch.tensor(angle_z, device=device, dtype=dtype) * (torch.pi / 180.0)
    else:
        angle_x = torch.tensor(angle_x, device=device, dtype=dtype)
        angle_y = torch.tensor(angle_y, device=device, dtype=dtype)
        angle_z = torch.tensor(angle_z, device=device, dtype=dtype)

    cos_x, sin_x = torch.cos(angle_x), torch.sin(angle_x)
    R_x = torch.eye(3, device=device, dtype=dtype)
    R_x[1, 1] = cos_x; R_x[1, 2] = -sin_x; R_x[2, 1] = sin_x; R_x[2, 2] = cos_x

    cos_y, sin_y = torch.cos(angle_y), torch.sin(angle_y)
    R_y = torch.eye(3, device=device, dtype=dtype)
    R_y[0, 0] = cos_y; R_y[0, 2] = sin_y; R_y[2, 0] = -sin_y; R_y[2, 2] = cos_y

    cos_z, sin_z = torch.cos(angle_z), torch.sin(angle_z)
    R_z = torch.eye(3, device=device, dtype=dtype)
    R_z[0, 0] = cos_z; R_z[0, 1] = -sin_z; R_z[1, 0] = sin_z; R_z[1, 1] = cos_z

    return torch.matmul(R_z @ R_y @ R_x, rotmat)


def generate_rotation_sequence(angle_ranges, device="cpu"):
    """Generate camera orientations (as 6D) for the turntable views."""
    orient = torch.eye(3, device=device, dtype=torch.float32)
    orient = rotate_rotmat(orient, angle_x=90, angle_y=0, angle_z=0)
    orient = rotate_rotmat(orient, angle_x=0, angle_y=90, angle_z=0)
    orient = rotate_rotmat(orient, angle_x=3, angle_y=0, angle_z=0)

    angle_ys, angle_xs, angle_zs = [], [], []
    for azim_range, elev_range, roll_range in angle_ranges:
        angle_ys.append(np.random.uniform(azim_range[0], azim_range[1]))
        angle_xs.append(np.random.uniform(elev_range[0], elev_range[1]))
        angle_zs.append(np.random.uniform(roll_range[0], roll_range[1]))

    orient_6d_list = []
    for i in range(len(angle_xs)):
        f = orient
        f = rotate_rotmat(f, angle_x=0, angle_y=angle_ys[i], angle_z=0)
        f = rotate_rotmat(f, angle_x=angle_xs[i], angle_y=0, angle_z=0)
        f = rotate_rotmat(f, angle_x=0, angle_y=0, angle_z=angle_zs[i])
        orient_6d_list.append(f[..., :2].reshape(1, 1, 6))
    return torch.cat(orient_6d_list, dim=0)


def setup_output_dirs(output_dir, args):
    """Create output directories based on enabled render options."""
    output_dir = Path(output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)
    dirs = {}
    if args.save_rgb:
        dirs["rgb"] = output_dir / "rgb"; dirs["rgb"].mkdir(exist_ok=True)
    if args.save_keypoints:
        dirs["rgb_with_keypoints2d"] = output_dir / "rgb_with_keypoints2d"; dirs["rgb_with_keypoints2d"].mkdir(exist_ok=True)
    if args.save_depth:
        dirs["depth"] = output_dir / "depth"; dirs["depth"].mkdir(exist_ok=True)
    if args.save_mask:
        dirs["mask"] = output_dir / "seg"; dirs["mask"].mkdir(exist_ok=True)
    if args.save_canny:
        dirs["canny"] = output_dir / "canny"; dirs["canny"].mkdir(exist_ok=True)
    return dirs


def render_frame(smal_mesh, keyp_3d, camera, renderer, args):
    """Render a single frame with requested outputs."""
    results = {}
    rgb_rgba = renderer.render(smal_mesh, camera, color=None)
    rgb = rgb_rgba[..., :3]
    results["rgb"] = rgb
    if args.save_mask:
        results["mask"] = (rgb_rgba[..., 3] > 0).astype(np.uint8) * 255
    if args.save_depth:
        depth = renderer.render(smal_mesh, camera, depth_only=True)
        depth[depth == 0] = np.nan
        dn = 1 - (depth - np.nanmin(depth)) / (np.nanmax(depth) - np.nanmin(depth))
        dn[np.isnan(dn)] = 0
        results["depth"] = np.rint(dn * 255).astype(np.uint8)
    if args.save_canny:
        results["canny"] = cv2.Canny(rgb, 100, 200)
    keyp_2d = project_keypoints_to_2d(keyp_3d, camera, img_size=args.resolution)
    results["keypoints2d"] = (keyp_2d / (args.resolution - 1) * 2 - 1)[None]
    if args.save_keypoints:
        results["rgb_with_keypoints2d"] = draw_keypoints_on_image(
            rgb, keyp_2d, radius=max(2, args.resolution // 128), color=(255, 0, 0), thickness=-1)
    return results


def save_frame_results(results, view_name, output_dirs):
    for key, img in results.items():
        if key in output_dirs:
            Image.fromarray(img).save(output_dirs[key] / f"{view_name}.png")


def create_gifs(output_dir, output_dirs, file_names, fps=6):
    import imageio
    for name, dir_path in output_dirs.items():
        images = []
        for file_name in file_names:
            p = dir_path / f"{file_name}.png"
            if p.exists():
                images.append(imageio.imread(p))
        if images:
            gif_path = output_dir / "gif" / f"{name}.gif"
            gif_path.parent.mkdir(parents=True, exist_ok=True)
            imageio.mimsave(gif_path, images, format="GIF", fps=fps, loop=0)


def process_single_pose(pose_idx, pose_6d_single, args, shapes, textures, angle_ranges, num_views, renderer):
    """Render all views for one pose, sampling a random shape+texture per view."""
    shape_beta, shape_blimbs, shape_pose, logscale_part_shared = shapes
    texture_pngs, atlas = textures

    output_dir = Path(args.output_root) / f"pose_{pose_idx:06d}"
    output_dirs = setup_output_dirs(output_dir, args)

    pose_6d_from_motion = torch.from_numpy(np.asarray(pose_6d_single)).float()
    if pose_6d_from_motion.ndim == 2:
        pose_6d_from_motion = pose_6d_from_motion.unsqueeze(0)
    if args.apply_horizontal_flip:
        pose_6d_from_motion = apply_horizontal_flip_(pose_6d_from_motion, args.device)

    # Random shapes for this pose (one per view).
    num_shapes = shape_beta.shape[0]
    shape_ids = random.choices(range(num_shapes), k=num_views)
    beta_list = [torch.from_numpy(shape_beta[s:s + 1]).float() for s in shape_ids]
    betas_limbs_list = [torch.from_numpy(shape_blimbs[s:s + 1]).float() for s in shape_ids]
    pose_6d_from_shape_list = [torch.from_numpy(shape_pose[s:s + 1]).float() for s in shape_ids]

    # Blend pose: motion pose everywhere, shape-specific shape pose for the ear joints.
    pose_6d_list = []
    for i in range(num_views):
        blended = pose_6d_from_motion.clone()
        blended[:, EAR_JOINT_INDICES, :] = pose_6d_from_shape_list[i][:, EAR_JOINT_INDICES, :]
        pose_6d_list.append(blended)

    # Random textures for this pose (one per view); all share the single UV atlas.
    tex_ids = random.choices(range(len(texture_pngs)), k=num_views)
    uvmap_image_list = [Image.open(texture_pngs[t]) for t in tex_ids]
    xatlas_params_list = [atlas for _ in tex_ids]

    orient_6d_list = generate_rotation_sequence(angle_ranges, device=args.device)

    beta_batch = torch.cat(beta_list, dim=0)
    betas_limbs_batch = torch.cat(betas_limbs_list, dim=0)
    pose_6d_batch = torch.cat(pose_6d_list, dim=0)

    if args.tail_drop_prob > 0.0:
        mask = torch.rand(betas_limbs_batch.shape[0]) < args.tail_drop_prob
        if "tail_l" in logscale_part_shared:
            betas_limbs_batch[mask, logscale_part_shared.index("tail_l")] = -6
        if "tail_f" in logscale_part_shared:
            betas_limbs_batch[mask, logscale_part_shared.index("tail_f")] = -6

    smal_outputs = initialize_smal_model_batch(
        keyp_conf="all",
        beta_batch=beta_batch,
        betas_limbs_batch=betas_limbs_batch,
        logscale_part_list=logscale_part_shared,
        pose_6d_batch=pose_6d_batch,
        orient_6d_batch=orient_6d_list,
        uvmap_image_list=uvmap_image_list,
        xatlas_params_list=xatlas_params_list,
    )

    for frame_idx in range(num_views):
        view_name = args.view_names[frame_idx]
        smal_output = smal_outputs[frame_idx]
        orient_6d_frame = orient_6d_list[frame_idx]
        smal_mesh = smal_output["mesh"]
        keyp_3d = smal_output["keyp_3d"].data.cpu()

        verts = smal_mesh.vertices
        s, tx, ty = np.array(deduce_weak_perspective_params(
            verts, img_size=(args.resolution, args.resolution), random=args.random_camera)) / args.resolution
        s *= 2
        tx = (tx - 0.5) * 2
        ty = (ty - 0.5) * 2
        camera = np.array([s, s, tx / s, ty / s])

        results = render_frame(smal_mesh, keyp_3d, camera, renderer, args)
        save_frame_results(results, view_name, output_dirs)

        if args.save_npz:
            metadata = {
                "camera/scale": s, "camera/tx": tx, "camera/ty": ty,
                "smal/beta": smal_output["beta"].cpu().numpy(),
                "smal/betas_limbs": smal_output["betas_limbs"].cpu().numpy(),
                "smal/vert_off_compact": smal_output["vert_off_compact"].cpu().numpy(),
                "smal/trans": smal_output["trans"].cpu().numpy(),
                "smal/orient_6d": orient_6d_frame.cpu().numpy(),
                "smal/pose_6d": pose_6d_batch[frame_idx:frame_idx + 1].cpu().numpy(),
                "smal/keyp_conf": smal_output["keyp_conf"],
                "smal/keyp_3d_all": keyp_3d.cpu().numpy(),
                "smal/keyp_2d_all": results["keypoints2d"],
                "smal/logscale_part_list": smal_output["logscale_part_list"],
                "smal/smal_model_type": smal_output["smal_model_type"],
            }
            (output_dir / "npz").mkdir(parents=True, exist_ok=True)
            np.savez_compressed(output_dir / "npz" / f"{view_name}.npz", **metadata)

    if args.create_gif:
        create_gifs(output_dir, output_dirs, list(args.view_names))


def argument_parser():
    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    p.add_argument("--pose_npz", required=True, help="library/poses/poses.npz")
    p.add_argument("--shape_npz", required=True, help="library/shapes/shapes.npz")
    p.add_argument("--texture_dir", required=True, help="library/textures/ (texture_*.png + uv_atlas_*.pth + uv_atlas_index.npy)")
    p.add_argument("--output_root", required=True, help="Output root directory for rendered poses")
    p.add_argument("--bite_root", default="./bite_gradio-hf", help="BITE checkout (code + SMAL weights); see scripts/setup.sh")
    p.add_argument("--views", default=None, help="Comma-separated view names; default 00..59")
    p.add_argument("--resolution", type=int, default=256, help="Square image resolution")
    p.add_argument("--device", default="cuda", help="torch device")
    p.add_argument("--apply_horizontal_flip", type=str2bool, default=False)
    p.add_argument("--save_rgb", type=str2bool, default=True)
    p.add_argument("--save_keypoints", type=str2bool, default=False)
    p.add_argument("--save_depth", type=str2bool, default=False)
    p.add_argument("--save_mask", type=str2bool, default=True)
    p.add_argument("--save_canny", type=str2bool, default=False)
    p.add_argument("--save_npz", type=str2bool, default=True)
    p.add_argument("--create_gif", type=str2bool, default=False)
    p.add_argument("--random_camera", type=str2bool, default=False)
    p.add_argument("--tail_drop_prob", type=float, default=0.0)
    p.add_argument("--process_id", type=int, default=0)
    p.add_argument("--num_processes", type=int, default=1)
    p.add_argument("--pose_indices_file", default=None, help="File of pose indices (one per line); overrides process partitioning")
    # Sharding (default ON, single-process)
    p.add_argument("--shard", type=str2bool, default=True, help="Pack rendered poses into stored tar shards")
    p.add_argument("--shard_dir", default=None, help="Shard output dir (default: <output_root>_shards)")
    p.add_argument("--shard_size", type=int, default=1750, help="Poses per shard")
    p.add_argument("--shard_cleanup", type=str2bool, default=False, help="Delete loose pose dirs after sharding")
    p.add_argument("--seed", type=int, default=0, help="Base RNG seed (offset by process_id)")
    return p.parse_args()


def main():
    from tqdm import tqdm
    args = argument_parser()

    if args.views is None:
        args.views = ",".join(f"{i:02d}" for i in range(60))
    args.view_names = args.views.split(",")
    num_views = len(args.view_names)

    # 4 azimuths x 5 elevations x 3 rolls = 60 views
    azim_ranges = [[-45, 45], [45, 135], [135, 225], [225, 315]]
    elev_ranges = [[60, 90], [15, 60], [-15, 15], [-60, -15], [-90, -60]]
    roll_ranges = [[-180, -60], [-60, 60], [60, 180]]
    angle_ranges = [(a, e, r) for a in azim_ranges for e in elev_ranges for r in roll_ranges]
    assert len(angle_ranges) == num_views, \
        f"--views count ({num_views}) must match angle_ranges ({len(angle_ranges)})"

    random.seed(args.seed + args.process_id)
    np.random.seed(args.seed + args.process_id)

    print(f"Loading poses from {args.pose_npz} ...")
    all_poses = np.load(args.pose_npz, allow_pickle=True)["pose_6d"]
    total_poses = len(all_poses)
    print(f"Loaded {total_poses} poses {all_poses.shape}")

    if args.pose_indices_file is not None:
        pose_indices = [int(l.strip()) for l in open(args.pose_indices_file) if l.strip()]
    else:
        per = (total_poses + args.num_processes - 1) // args.num_processes
        start = args.process_id * per
        pose_indices = list(range(start, min(start + per, total_poses)))
    print(f"[Process {args.process_id}/{args.num_processes}] {len(pose_indices)} poses")

    # Load the consolidated shape library once.
    sd = np.load(args.shape_npz, allow_pickle=True)
    shapes = (sd["beta"], sd["betas_limbs"], sd["pose_6d"], list(sd["logscale_part_list"]))
    print(f"Loaded {shapes[0].shape[0]} shapes")

    # Load the texture library once: flat PNGs + a single shared UV atlas.
    tex_dir = Path(args.texture_dir)
    texture_pngs = sorted(tex_dir.glob("texture_*.png"))
    atlas_path = tex_dir / "uv_atlas.pth"
    if not atlas_path.exists():
        atlas_path = tex_dir / "uv_atlas_0.pth"      # backward-compat with older 2-atlas builds
    atlas = torch.load(atlas_path, weights_only=False)
    textures = (texture_pngs, atlas)
    print(f"Loaded {len(texture_pngs)} textures (single UV atlas: {atlas_path.name})")

    renderer = MeshRenderer(resolution=(args.resolution, args.resolution), randomize_light_orientation=True)

    for pose_idx in tqdm(pose_indices, desc=f"[Process {args.process_id}] Rendering"):
        process_single_pose(pose_idx, all_poses[pose_idx], args, shapes, textures,
                             angle_ranges, num_views, renderer)

    try:
        if hasattr(renderer.renderer, "delete"):
            renderer.renderer.delete()
    except Exception:
        pass

    # Optional sharding (single-process).
    if args.shard:
        if args.num_processes > 1:
            print("[shard] skipped: --num_processes > 1. Render loose, then pack with "
                  "build/03_pack_renders_to_shards.py or a single-process --shard run.")
        else:
            shard_dir = args.shard_dir or (str(args.output_root).rstrip("/") + "_shards")
            mods = shard_utils.modalities_from_flags(
                args.save_rgb, args.save_mask, args.save_npz,
                args.save_keypoints, args.save_depth, args.save_canny)
            items = [(pid, str(Path(args.output_root) / f"pose_{pid:06d}")) for pid in pose_indices]
            shard_utils.pack_to_shards(items, shard_dir, args.shard_size, modalities=mods,
                                       index_csv=os.path.join(shard_dir, "shards_index.csv"))
            if args.shard_cleanup:
                import shutil
                for pid in pose_indices:
                    shutil.rmtree(Path(args.output_root) / f"pose_{pid:06d}", ignore_errors=True)
                print("[shard] removed loose pose dirs")

    print(f"[Process {args.process_id}] Done. {len(pose_indices)} poses.")


if __name__ == "__main__":
    main()