"""Evaluate the direct-joint PPO policy and non-learning baselines."""

from __future__ import annotations

import argparse
import json
from pathlib import Path
from typing import Callable

import numpy as np
from stable_baselines3 import PPO

from fixed_line_learned_env import G1LearnedFixedLineEnv


def resolve_model(requested: str | None = None) -> Path:
    if requested is not None:
        requested_path = Path(requested)
        if requested_path.exists():
            return requested_path.resolve()
        raise FileNotFoundError(f"Requested checkpoint not found: {requested_path}")
    candidates = [
        Path("models/ppo_fixed_line_learned/g1_fixed_line_direct_final.zip"),
        Path("models/ppo_fixed_line_learned/best/best_model.zip"),
        Path("models/ppo_fixed_line_learned/g1_fixed_line_direct_last.zip"),
    ]
    for candidate in candidates:
        if candidate is not None and candidate.exists():
            return candidate.resolve()
    raise FileNotFoundError(
        "No direct-joint checkpoint found. Run train_fixed_line_learned.py "
        "or pass --model."
    )


def rollout_policy(
    action_fn: Callable[[np.ndarray, G1LearnedFixedLineEnv], np.ndarray],
    seed: int,
    randomize: bool,
    curriculum_stage: str = "full",
) -> dict[str, float | bool | int]:
    env = G1LearnedFixedLineEnv(
        randomize_reset=randomize,
        curriculum_stage=curriculum_stage,
    )
    observation, info = env.reset(seed=seed, options={"randomize": randomize})
    total_reward = 0.0
    line_load_peak = 0.0
    lanyard_load_peak = 0.0
    line_support_sum = 0.0
    ground_load_peak = 0.0
    minimum_rope_snow_contacts = np.inf
    rope_leg_contact_steps = 0
    minimum_rope_leg_center_clearance = np.inf
    peak_rope_strain = 0.0
    peak_rope_lift = 0.0
    rope_cam_contact_steps = 0
    peak_lateral_offset = 0.0
    minimum_heading_alignment = np.inf
    minimum_pelvis_normal_height = np.inf
    minimum_backward_lean = np.inf
    maximum_backward_lean = -np.inf
    nonfoot_snow_contact_steps = 0
    contacts = {"left": 0, "right": 0, "any": 0, "double": 0}
    for step in range(env.max_episode_steps):
        action = action_fn(observation, env)
        observation, reward, terminated, truncated, info = env.step(action)
        total_reward += reward
        line_load_peak = max(line_load_peak, float(info["ascender_load_n"]))
        lanyard_load_peak = max(
            lanyard_load_peak, float(info["lanyard_load_n"])
        )
        line_support_sum += float(info["line_support_fraction"])
        ground_load_peak = max(ground_load_peak, float(info["ground_load_n"]))
        left = bool(info["left_boot_contact"])
        right = bool(info["right_boot_contact"])
        contacts["left"] += int(left)
        contacts["right"] += int(right)
        contacts["any"] += int(left or right)
        contacts["double"] += int(left and right)
        rope_snow_contacts, rope_touches_leg = env.rope_contact_audit()
        minimum_rope_snow_contacts = min(
            minimum_rope_snow_contacts, rope_snow_contacts
        )
        rope_leg_contact_steps += int(rope_touches_leg)
        minimum_rope_leg_center_clearance = min(
            minimum_rope_leg_center_clearance,
            float(info["rope_leg_center_clearance_m"]),
        )
        peak_rope_strain = max(
            peak_rope_strain, float(info["rope_strain"])
        )
        peak_rope_lift = max(
            peak_rope_lift, float(info["rope_max_lift_m"])
        )
        rope_cam_contact_steps += int(info["rope_cam_contacts"] > 0)
        peak_lateral_offset = max(
            peak_lateral_offset, float(info["lateral_offset"])
        )
        minimum_heading_alignment = min(
            minimum_heading_alignment, float(info["line_heading_alignment"])
        )
        minimum_pelvis_normal_height = min(
            minimum_pelvis_normal_height,
            float(info["pelvis_normal_height"]),
        )
        minimum_backward_lean = min(
            minimum_backward_lean, float(info["backward_lean"])
        )
        maximum_backward_lean = max(
            maximum_backward_lean, float(info["backward_lean"])
        )
        nonfoot_snow_contact_steps += int(info["nonfoot_snow_contact"])
        if terminated or truncated:
            break
    elapsed = step + 1
    result: dict[str, float | bool | int] = {
        "seed": seed,
        "success": bool(info["success"]),
        "failure": bool(info["failure"]),
        "policy_steps": elapsed,
        "return": total_reward,
        "ascent_m": float(info["ascent"]),
        "ascender_advance_m": float(info["ascender_advance"]),
        "physical_landings": int(info["physical_landings"]),
        "alternating_landings": int(info["alternating_landings"]),
        "current_boot_anchor_loss_m": float(
            info["current_boot_anchor_loss_m"]
        ),
        "maximum_boot_anchor_loss_m": float(
            info["maximum_boot_anchor_loss_m"]
        ),
        "maximum_single_support_steps": int(
            info["maximum_single_support_steps"]
        ),
        "maximum_supported_single_support_steps": int(
            info["maximum_supported_single_support_steps"]
        ),
        "maximum_swing_advance_m": float(
            info["maximum_swing_advance_m"]
        ),
        "maximum_supported_swing_advance_m": float(
            info["maximum_supported_swing_advance_m"]
        ),
        "maximum_shaped_supported_swing_advance_m": float(
            info["maximum_shaped_supported_swing_advance_m"]
        ),
        "technique_cycles": int(info["technique_cycles"]),
        "right_elbow_peak_rad": float(info["right_elbow_peak_rad"]),
        "right_elbow_excursion_rad": float(info["right_elbow_excursion_rad"]),
        "descent_from_high_water_m": float(info["descent_from_high_water"]),
        "upright_score": float(info["upright_score"]),
        "minimum_heading_alignment": minimum_heading_alignment,
        "minimum_backward_lean": minimum_backward_lean,
        "maximum_backward_lean": maximum_backward_lean,
        "pelvis_normal_height_m": float(info["pelvis_normal_height"]),
        "minimum_pelvis_normal_height_m": minimum_pelvis_normal_height,
        "final_lateral_offset_m": float(info["lateral_offset"]),
        "peak_lateral_offset_m": peak_lateral_offset,
        "grip_constraint_error_m": float(info["grip_constraint_error_m"]),
        "peak_ascender_load_n": line_load_peak,
        "peak_lanyard_load_n": lanyard_load_peak,
        "mean_lanyard_load_n": float(info["mean_lanyard_load_n"]),
        "mean_active_lanyard_load_n": float(
            info["mean_active_lanyard_load_n"]
        ),
        "mean_line_support_fraction": line_support_sum / elapsed,
        "line_loaded_fraction": float(info["line_loaded_fraction"]),
        "maximum_target_lanyard_support_streak": int(
            info["maximum_target_lanyard_support_streak"]
        ),
        "target_lanyard_support_duration_s": float(
            info["maximum_target_lanyard_support_streak"] * env.policy_dt
        ),
        "peak_ground_load_n": ground_load_peak,
        "left_contact_fraction": contacts["left"] / elapsed,
        "right_contact_fraction": contacts["right"] / elapsed,
        "grounded_fraction": contacts["any"] / elapsed,
        "double_support_fraction": contacts["double"] / elapsed,
        "maximum_airborne_streak": int(info["maximum_airborne_streak"]),
        "maximum_rope_cam_lost_streak": int(
            info["maximum_rope_cam_lost_streak"]
        ),
        "nonfoot_snow_contact_steps": nonfoot_snow_contact_steps,
        "minimum_rope_snow_contacts": int(minimum_rope_snow_contacts),
        "rope_leg_contact_steps": rope_leg_contact_steps,
        "rope_leg_contact_fraction": rope_leg_contact_steps / elapsed,
        "minimum_rope_leg_center_clearance_m": (
            minimum_rope_leg_center_clearance
        ),
        "peak_rope_strain": peak_rope_strain,
        "peak_rope_lift_m": peak_rope_lift,
        "rope_cam_contact_fraction": rope_cam_contact_steps / elapsed,
    }
    env.close()
    return result


def _summary(episodes: list[dict[str, float | bool | int]]) -> dict:
    numeric_keys = [
        key
        for key, value in episodes[0].items()
        if key not in ("seed", "success", "failure")
        and isinstance(value, (int, float))
    ]
    return {
        "episodes": len(episodes),
        "successes": sum(bool(episode["success"]) for episode in episodes),
        "failures": sum(bool(episode["failure"]) for episode in episodes),
        "success_rate": float(
            np.mean([bool(episode["success"]) for episode in episodes])
        ),
        "mean": {
            key: float(np.mean([float(episode[key]) for episode in episodes]))
            for key in numeric_keys
        },
        "minimum": {
            key: float(np.min([float(episode[key]) for episode in episodes]))
            for key in numeric_keys
        },
        "maximum": {
            key: float(np.max([float(episode[key]) for episode in episodes]))
            for key in numeric_keys
        },
        "rollouts": episodes,
    }


def evaluate(
    model_path: str | None = None,
    episodes: int = 10,
    output: str = "models/ppo_fixed_line_learned/evaluation_report.json",
    seed: int = 2100,
) -> dict:
    checkpoint = resolve_model(model_path)
    policy = PPO.load(checkpoint, device="cpu")
    if policy.action_space.shape != (len(G1LearnedFixedLineEnv.POLICY_JOINTS),):
        raise ValueError(
            f"Checkpoint has action shape {policy.action_space.shape}; expected "
            f"{(len(G1LearnedFixedLineEnv.POLICY_JOINTS),)} direct joint actions"
        )

    def learned(observation: np.ndarray, _env: G1LearnedFixedLineEnv) -> np.ndarray:
        action, _state = policy.predict(observation, deterministic=True)
        return np.asarray(action, dtype=np.float32)

    rng = np.random.default_rng(seed + 50_000)
    conditions = {
        "learned_direct_joint_policy": [
            rollout_policy(learned, seed + index, True)
            for index in range(episodes)
        ],
        "neutral_joint_residual": [
            rollout_policy(
                lambda _observation, env: np.zeros(
                    env.action_dim, dtype=np.float32
                ),
                seed + 10_000 + index,
                True,
            )
            for index in range(max(3, episodes // 2))
        ],
        "uniform_random_joint_residual": [
            rollout_policy(
                lambda _observation, env: rng.uniform(
                    -1.0, 1.0, env.action_dim
                ).astype(np.float32),
                seed + 20_000 + index,
                True,
            )
            for index in range(max(3, episodes // 2))
        ],
    }
    report = {
        "checkpoint": str(checkpoint),
        "controller_contract": {
            "observation_dim": int(policy.observation_space.shape[0]),
            "action_dim": int(policy.action_space.shape[0]),
            "actions": list(G1LearnedFixedLineEnv.POLICY_JOINTS),
            "scripted_motion": False,
            "runtime_inverse_kinematics": False,
            "external_robot_forces": False,
        },
        "conditions": {
            name: _summary(rollouts) for name, rollouts in conditions.items()
        },
    }
    destination = Path(output)
    destination.parent.mkdir(parents=True, exist_ok=True)
    destination.write_text(json.dumps(report, indent=2) + "\n")
    print(json.dumps(report, indent=2))
    return report


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--model")
    parser.add_argument("--episodes", type=int, default=10)
    parser.add_argument(
        "--output",
        default="models/ppo_fixed_line_learned/evaluation_report.json",
    )
    parser.add_argument("--seed", type=int, default=2100)
    arguments = parser.parse_args()
    evaluate(arguments.model, arguments.episodes, arguments.output, arguments.seed)