"""Trace Task-E policy rollout with object positions at fixed intervals."""

import argparse
import os
import sys

from isaaclab.app import AppLauncher


parser = argparse.ArgumentParser()
parser.add_argument("--checkpoint", required=True)
parser.add_argument("--solution_module", default="solution_act")
parser.add_argument("--task", default="ATEC-TaskE-Piper")
parser.add_argument("--seed", type=int, default=11)
parser.add_argument("--max_steps", type=int, default=1800)
parser.add_argument("--interval", type=int, default=100)
AppLauncher.add_app_launcher_args(parser)
args_cli = parser.parse_args()
args_cli.enable_cameras = True

repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
demo_dir = os.path.join(repo_root, "demo")
if repo_root not in sys.path:
    sys.path.insert(0, repo_root)
if demo_dir not in sys.path:
    sys.path.insert(0, demo_dir)
os.environ["ATEC_ACT_POLICY_PATH"] = os.path.abspath(args_cli.checkpoint)

app_launcher = AppLauncher(args_cli)
simulation_app = app_launcher.app

import importlib  # noqa: E402

import gymnasium as gym  # noqa: E402
import torch  # noqa: E402
from isaaclab.envs import DirectMARLEnv, multi_agent_to_single_agent  # noqa: E402
from isaaclab_tasks.utils import parse_env_cfg  # noqa: E402

import atec_rl_lab.tasks  # noqa: F401,E402
from scripts.act.task_e.collector import basket_status_lines  # noqa: E402


def _object_summary(env) -> str:
    return " | ".join(basket_status_lines(env, [1, 2, 3]))


def main() -> None:
    env_cfg = parse_env_cfg(args_cli.task, device=args_cli.device, num_envs=1)
    env_cfg.seed = args_cli.seed
    env = gym.make(args_cli.task, cfg=env_cfg)
    if isinstance(env.unwrapped, DirectMARLEnv):
        env = multi_agent_to_single_agent(env)

    policy = importlib.import_module(args_cli.solution_module).AlgSolution()
    obs, _ = env.reset(seed=args_cli.seed)
    policy.reset_episode()
    total_reward = 0.0

    try:
        print(f"[TRACE_STEP] step=0 score=0.00 {_object_summary(env)}", flush=True)
        for step in range(1, args_cli.max_steps + 1):
            with torch.inference_mode():
                resp = policy.predicts(obs, total_reward)
                action = torch.as_tensor(resp["action"], dtype=torch.float32, device=args_cli.device).view(1, -1)
                obs, reward, terminated, truncated, info = env.step(action)
            sim_dt = info["Step_dt"]
            total_reward += reward.mean().item() / sim_dt if isinstance(reward, torch.Tensor) else float(reward) / sim_dt
            if step % args_cli.interval == 0 or bool(terminated.item() or truncated.item()):
                print(
                    f"[TRACE_STEP] step={step} score={total_reward:.2f} {_object_summary(env)}",
                    flush=True,
                )
            if bool(terminated.item() or truncated.item()):
                break
        print(f"[RESULT] score={total_reward:.2f} steps={step}", flush=True)
    finally:
        env.close()


if __name__ == "__main__":
    try:
        main()
    finally:
        simulation_app.close()