"""Installation checks, fixed-scene smoke checks, expert replay and reference export."""
import argparse
import contextlib
import importlib.metadata
import json
from pathlib import Path
import sys

from .runtime import RESOURCES, configure, reference_manifest, evaluation_protocol, task_manifest


def ids(value, available):
    selected = list(available) if value == "all" else [int(v) for v in value.split(",")]
    if not selected or len(set(selected)) != len(selected) or set(selected) - set(available):
        raise ValueError(f"ids must be unique members of {list(available)}")
    return selected


def doctor():
    from . import get_suite
    suite = get_suite()
    if suite.n_tasks != len(task_manifest()):
        raise ValueError("task count differs from manifest")
    return dict(passed=True, tasks=suite.n_tasks,
                references=[r["id"] for r in reference_manifest()["references"]],
                packages={p: importlib.metadata.version(p) for p in
                          ("numpy", "scipy", "torch", "mujoco", "robosuite", "h5py", "PyOpenGL")})


def smoke(task_id):
    import numpy as np
    from . import get_suite, make_env
    protocol = evaluation_protocol()
    env, obs = make_env(task_id)
    try:
        initial = get_suite().get_task_init_states(task_id)[protocol["initial_state_indices"][0]]
        state_error = float(np.max(np.abs(env.sim.get_state().flatten() - initial)))
        if state_error > 1e-12 or env.check_success():
            raise ValueError("fixed initial state mismatch")
        def validate_images(observation):
            for camera in protocol["camera_names"]:
                image = observation[camera + "_image"]
                if image.shape != (*protocol["camera_resolution"], 3) or image.dtype != np.uint8:
                    raise ValueError("invalid camera observation")

        validate_images(obs)
        before = float(env.sim.data.time)
        obs, _, _, _ = env.step([0, 0, 0, 0, 0, 0, -1])
        validate_images(obs)
        elapsed = float(env.sim.data.time) - before
        if not np.isclose(elapsed, 1 / protocol["control_frequency_hz"], atol=1e-9):
            raise ValueError("incorrect native step frequency")
        return dict(id=task_id, passed=True, initial_state_error=state_error,
                    camera_names=protocol["camera_names"],
                    camera_resolution=protocol["camera_resolution"],
                    initialization_steps=0, elapsed_seconds=elapsed,
                    success_after_one_step=bool(env.check_success()))
    finally:
        env.close()


def replay(task_id):
    import h5py
    import numpy as np
    from . import make_env
    row = next(r for r in reference_manifest()["references"] if r["id"] == task_id)
    folder = RESOURCES / "expert_reference"
    with h5py.File(folder / row["files"]["dataset"]["path"], "r") as f:
        actions = f["data/demo_0/actions"][:]
        first = f["data/demo_0/states"][0]
    env, _ = make_env(task_id, camera_obs=False)
    try:
        error = float(np.max(np.abs(first - env.sim.get_state().flatten())))
        if error > 1e-12:
            raise ValueError("expert and test initial state differ")
        first_success = None
        for i, action in enumerate(actions, 1):
            env.step(action)
            if env.check_success() and first_success is None:
                first_success = i
        if not env.check_success():
            raise ValueError(f"expert replay did not succeed: {task_id}")
        return dict(id=task_id, success=True, actions=len(actions),
                    first_success_step=first_success, initial_state_error=error)
    finally:
        env.close()


def main(argv=None):
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("command", choices=("doctor", "smoke", "replay-experts", "export-references"))
    parser.add_argument("--ids", default="all")
    parser.add_argument("--renderer", choices=("osmesa", "egl"), default="osmesa")
    parser.add_argument("--output", type=Path,
                        help="required destination directory for export-references; optional JSON report otherwise")
    args = parser.parse_args(argv)
    if args.command == "export-references" and args.output is None:
        parser.error("export-references requires --output DIRECTORY")
    results = []
    try:
        configure(renderer=args.renderer)
        if args.command == "export-references":
            from .export_references import convert
            rows = {r["id"]: r for r in reference_manifest()["references"]}
            selected = ids(args.ids, rows)
            output = args.output.expanduser().resolve()
            for tid in selected:
                destination = output / f"task_{tid:03d}"
                if destination.exists() or destination.is_symlink():
                    raise FileExistsError(f"refusing to overwrite {destination}")
            for tid in selected:
                with contextlib.redirect_stdout(sys.stderr):
                    result = convert(rows[tid], output / f"task_{tid:03d}")
                print(json.dumps(result), flush=True)
            return 0
        if args.command == "doctor":
            with contextlib.redirect_stdout(sys.stderr):
                results.append(doctor())
            print(json.dumps(results[-1]), flush=True)
        else:
            available = ([t["id"] for t in task_manifest()] if args.command == "smoke"
                         else [r["id"] for r in reference_manifest()["references"]])
            for tid in ids(args.ids, available):
                with contextlib.redirect_stdout(sys.stderr):
                    result = smoke(tid) if args.command == "smoke" else replay(tid)
                results.append(result)
                print(json.dumps(result), flush=True)
        if args.output:
            args.output.parent.mkdir(parents=True, exist_ok=True)
            args.output.write_text(json.dumps(dict(passed=True, command=args.command, results=results), indent=2) + "\n")
        return 0
    except (ValueError, OSError) as exc:
        parser.exit(1, str(exc) + "\n")


if __name__ == "__main__":
    raise SystemExit(main())