#!/usr/bin/env python
"""Benchmark GPUDrive NuScenes environment throughput without PPO training."""

from __future__ import annotations

import argparse
import os
import time
from pathlib import Path

import torch

from gpudrive.env.config import EnvConfig, RenderConfig
from gpudrive.env.dataset import SceneDataLoader
from gpudrive.env.env_torch import GPUDriveTorchEnv


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser()
    parser.add_argument("--data-dir", default="data/processed/nuscenes")
    parser.add_argument("--num-worlds", type=int, default=75)
    parser.add_argument("--dataset-size", type=int, default=10000)
    parser.add_argument("--steps", type=int, default=200)
    parser.add_argument("--warmup-steps", type=int, default=20)
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--device", default="cuda")
    parser.add_argument("--obs-radius", type=float, default=50.0)
    parser.add_argument("--polyline-reduction-threshold", type=float, default=0.1)
    parser.add_argument("--max-controlled-agents", type=int, default=64)
    parser.add_argument("--remove-non-vehicles", type=int, default=1)
    parser.add_argument("--init-mode", default="all_valid")
    parser.add_argument("--action-mode", choices=["zero", "random"], default="zero")
    return parser.parse_args()


def sync_if_cuda(device: str) -> None:
    if device == "cuda":
        torch.cuda.synchronize()


def main() -> None:
    args = parse_args()
    torch.manual_seed(args.seed)

    project_root = Path(__file__).resolve().parents[1]
    data_dir = (project_root / args.data_dir).resolve()
    os.chdir(project_root / "gpudrive")

    device = args.device
    if device == "cuda" and not torch.cuda.is_available():
        device = "cpu"

    data_loader = SceneDataLoader(
        root=str(data_dir),
        batch_size=args.num_worlds,
        dataset_size=args.dataset_size,
        sample_with_replacement=True,
        shuffle=True,
        seed=args.seed,
    )

    env_config = EnvConfig(
        ego_state=True,
        road_map_obs=True,
        partner_obs=True,
        norm_obs=True,
        reward_type="weighted_combination",
        dynamics_model="classic",
        collision_behavior="ignore",
        remove_non_vehicles=bool(args.remove_non_vehicles),
        obs_radius=args.obs_radius,
        polyline_reduction_threshold=args.polyline_reduction_threshold,
        init_mode=args.init_mode,
    )
    env = GPUDriveTorchEnv(
        config=env_config,
        render_config=RenderConfig(render_3d=False),
        data_loader=data_loader,
        max_cont_agents=args.max_controlled_agents,
        device=device,
    )
    control_mask = env.cont_agent_mask.clone()
    num_controlled = int(control_mask.sum().item())
    total_slots = env.num_worlds * env.max_agent_count

    print(
        "[bench] env ready:",
        f"device={device}",
        f"num_worlds={env.num_worlds}",
        f"max_agent_count={env.max_agent_count}",
        f"controlled_agents={num_controlled}",
        f"obs_radius={args.obs_radius}",
        f"polyline_reduction_threshold={args.polyline_reduction_threshold}",
        flush=True,
    )

    generator = torch.Generator(device=device)
    generator.manual_seed(args.seed)

    def make_actions() -> torch.Tensor:
        if args.action_mode == "random":
            return torch.randint(
                low=0,
                high=env.action_space.n,
                size=(env.num_worlds, env.max_agent_count),
                generator=generator,
                device=device,
            )
        return torch.zeros(
            (env.num_worlds, env.max_agent_count),
            dtype=torch.int64,
            device=device,
        )

    for _ in range(args.warmup_steps):
        env.step_dynamics(make_actions())
        _ = env.get_obs(control_mask)
        _ = env.get_rewards()
        _ = env.get_infos()
        if bool(env.get_dones().all().item()):
            env.reset()

    sync_if_cuda(device)
    start = time.perf_counter()

    measured_steps = 0
    for _ in range(args.steps):
        env.step_dynamics(make_actions())
        _ = env.get_obs(control_mask)
        _ = env.get_rewards()
        _ = env.get_infos()
        measured_steps += 1
        if bool(env.get_dones().all().item()):
            env.reset()

    sync_if_cuda(device)
    elapsed = time.perf_counter() - start
    sim_steps_per_sec = measured_steps / elapsed
    controlled_sps = measured_steps * num_controlled / elapsed
    padded_sps = measured_steps * total_slots / elapsed

    print(
        "[bench] result:",
        f"elapsed_sec={elapsed:.3f}",
        f"sim_steps={measured_steps}",
        f"sim_steps_per_sec={sim_steps_per_sec:.2f}",
        f"controlled_agent_sps={controlled_sps:.2f}",
        f"padded_agent_sps={padded_sps:.2f}",
        flush=True,
    )

    env.close()


if __name__ == "__main__":
    main()