#!/usr/bin/env -S uv run --script
# /// script
# requires-python = ">=3.10"
# dependencies = ["dreamlake[video]==0.46.2"]
# ///
"""Synthetic PPO logging, with no MuJoCo, PyTorch, GPU, or real training.

Production (uses the existing DreamLake login; creates a missing private project):
  uv run --python 3.12 scripts/mock_rl_experiment.py --project my-workspace/rl-demo
Local rehearsal:
  uv run --python 3.12 scripts/mock_rl_experiment.py --project demo/rl-test --local-root /tmp/rl-data

Remote runs and their artifacts are intentionally retained for UI inspection.
"""

import argparse
import csv
import io
import json
import math
import platform
import random
import time
import uuid
from datetime import datetime, timezone
from importlib.metadata import version
from pathlib import Path

import numpy as np
from PIL import Image, ImageDraw
from dreamlake import Experiment


def frame(t: float) -> np.ndarray:
    """A deliberately synthetic locomotion preview, not a MuJoCo rendering."""
    image = Image.new("RGB", (640, 384), "#101827")
    draw = ImageDraw.Draw(image)
    draw.text((20, 18), "MOCK PPO / HalfCheetah - synthetic rollout", fill="white")
    draw.text((20, 38), f"simulation time: {t:.2f}s", fill="#94a3b8")
    draw.line((0, 290, 640, 290), fill="#64748b", width=3)
    for x in range(-40, 680, 80):
        offset = int((x - t * 120) % 720) - 40
        draw.line((offset, 292, offset - 18, 310), fill="#334155", width=2)
    y = 212 + int(8 * math.sin(t * 8))
    draw.line((220, y, 390, y - 8), fill="#38bdf8", width=16)
    draw.ellipse((382, y - 26, 420, y + 4), fill="#fbbf24")
    for x, phase in [(235, 0), (270, math.pi), (350, math.pi), (382, 0)]:
        swing = math.sin(t * 8 + phase)
        knee = (x + int(30 * swing), y + 38)
        foot = (x - int(35 * swing), 286)
        draw.line([(x, y), knee, foot], fill="#7dd3fc", width=7)
    return np.asarray(image)


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("--project", required=True, help="namespace/project; the SDK creates a missing project")
    parser.add_argument("--run", help="new run name (default: unique timestamp/seed name)")
    parser.add_argument("--dashrc", type=Path, default=Path(__file__).with_name("rl-dashboard.dashrc"), help="dashboard configuration saved with the run")
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--updates", type=int, default=60)
    parser.add_argument("--interval", type=float, default=0.03, help="pause between simulated updates, seconds")
    parser.add_argument("--api-url", default="https://api.dreamlake.ai")
    parser.add_argument("--local-root", type=Path, help="local-only rehearsal instead of production writes")
    args = parser.parse_args()
    if len(args.project.split("/")) != 2 or not all(args.project.split("/")):
        parser.error("--project must be namespace/project")
    if not 1 <= args.updates <= 1000 or not math.isfinite(args.interval) or args.interval < 0:
        parser.error("--updates must be 1..1000 and --interval must be finite and nonnegative")
    if not args.dashrc.is_file():
        parser.error("Download rl-dashboard.dashrc beside this script, or pass --dashrc PATH")
    dashboard_text = args.dashrc.read_text()
    name = args.run or f"ppo-halfcheetah-{datetime.now(timezone.utc):%Y%m%d-%H%M%S}-s{args.seed}-{uuid.uuid4().hex[:6]}"
    prefix = f"{args.project}/{name}"
    rng = random.Random(args.seed)
    config = {
        "mock": True, "algorithm": "PPO", "seed": args.seed,
        "environment": {"id": "HalfCheetah-v4", "num_envs": 8, "observation_dim": 17,
                        "action_dim": 6, "episode_horizon": 1000, "normalize_observations": True},
        "policy": {"hidden_sizes": [256, 256], "activation": "tanh", "distribution": "Gaussian"},
        "optimizer": {"name": "Adam", "learning_rate": 3e-4, "schedule": "linear", "max_grad_norm": 0.5},
        "ppo": {"rollout_steps": 1024, "minibatch_size": 256, "epochs": 10,
                "gamma": 0.99, "gae_lambda": 0.95, "clip_range": 0.2,
                "entropy_coefficient": 0.01, "value_coefficient": 0.5, "target_kl": 0.02},
        "evaluation": {"every_updates": 5, "episodes": 10, "success_return_threshold": 4000},
        "updates": args.updates, "env_steps_per_update": 8192,
    }
    runtime = {"python": platform.python_version(), "sdk": version("dreamlake"),
               "os": platform.system(), "architecture": platform.machine(), "device": "CPU (logging only)"}
    options = {"root": args.local_root} if args.local_root else {"url": args.api_url, "root": None}
    evaluations, checkpoints = [], []
    best_return, best_update = -math.inf, 0
    started = time.monotonic()
    readme = "# Mock PPO / HalfCheetah\n\nSynthetic production E2E data; no actual policy training or MuJoCo simulation.\n"
    with Experiment(prefix=prefix, readme=readme, tags=["rl", "ppo", "mock", "e2e"],
                    bindrs=["rl-e2e"], metadata={"mock": True, "purpose": "production-e2e", "sdk": runtime["sdk"]},
                    **options) as exp:
        print(json.dumps({"prefix": prefix, "run_id": exp.id, "mode": "local" if args.local_root else "production"}), flush=True)
        exp.params.set(**config)
        exp.files().save_text(dashboard_text, to=".dashrc")
        exp.files("config").save_json(config, to="hyperparameters.json")
        exp.files("config").save_json(runtime, to="runtime.json")
        exp.files("source").save_text(Path(__file__).read_text(), to="mock_rl_experiment.py")
        exp.logs.info("Starting synthetic PPO experiment; no real training", seed=args.seed)
        rollout = exp.metrics("rollout", description="Synthetic episode returns and reward components", tags=["rl"])
        train = exp.metrics("train", description="Synthetic PPO optimizer diagnostics")
        evaluation = exp.metrics("eval", description="Ten synthetic evaluation episodes; success means return >= 4000")
        system = exp.metrics("system", description="Observed logger timing and explicitly synthetic training hardware metrics")
        for update in range(1, args.updates + 1):
            progress = update / args.updates
            step = update * config["env_steps_per_update"]
            reward = 600 + 4200 * (1 - math.exp(-3.5 * progress)) + rng.gauss(0, 90)
            lr = config["optimizer"]["learning_rate"] * (1 - progress)
            rollout.log(update=update, global_step=step, episode_reward_mean=reward,
                        episode_reward_std=180 * (1 - progress) + 40,
                        episode_reward_min=reward - 300, episode_reward_max=reward + 280,
                        episode_length_mean=1000, forward_reward=reward + 90, control_cost=-90,
                        episodes_completed=update * 8)
            train.log(update=update, global_step=step, learning_rate=lr,
                      policy_loss=-0.12 * math.exp(-2 * progress) + rng.gauss(0, 0.003),
                      value_loss=90 * math.exp(-4 * progress) + rng.random(),
                      entropy=5.5 - 3.2 * progress, approx_kl=0.006 + rng.random() * 0.009,
                      clip_fraction=0.05 + rng.random() * 0.12,
                      explained_variance=min(0.98, 0.1 + 0.87 * progress),
                      gradient_norm=0.2 + rng.random() * 0.25, action_std=0.8 - 0.55 * progress)
            system.log(update=update, global_step=step, logger_elapsed_s=time.monotonic() - started,
                       process_cpu_s=time.process_time(), mock_env_fps=14000 + rng.randrange(3000),
                       mock_gpu_utilization_pct=60 + rng.random() * 25, mock_gpu_memory_mb=2048 + progress * 512)
            if update % 5 == 0 or update == args.updates:
                returns = [reward + rng.gauss(0, 130) for _ in range(10)]
                mean = sum(returns) / len(returns)
                row = {"update": update, "global_step": step, "return_mean": mean,
                       "return_std": (sum((r - mean) ** 2 for r in returns) / len(returns)) ** 0.5,
                       "return_min": min(returns), "return_max": max(returns),
                       "success_rate": sum(r >= 4000 for r in returns) / len(returns), "episodes": 10}
                evaluation.log(**row)
                evaluations.append(row)
                if mean > best_return:
                    best_return, best_update = mean, update
                exp.logs.info("Evaluation complete", update=update, global_step=step, return_mean=mean)
            if update == max(1, args.updates // 2):
                exp.logs.warn("Synthetic diagnostic: a brief KL spike was clipped; this is not a training failure", update=update)
            if update % max(1, args.updates // 3) == 0 or update == args.updates:
                filename = f"checkpoint-{update:04d}.json"
                checkpoint = {"mock": True, "loadable_training_checkpoint": False, "update": update,
                              "global_step": step, "optimizer": {"step": update, "learning_rate": lr},
                              "sample_policy_weights": [rng.gauss(0, 0.1) for _ in range(32)]}
                exp.files("checkpoints", tags=["checkpoint"]).save_json(checkpoint, to=filename)
                checkpoints.append(filename)
                exp.flush()
                print(f"update={update:3d} step={step:7d} reward={reward:8.2f}", flush=True)
            if args.interval:
                time.sleep(args.interval)

        frames = []
        for i in range(60):
            t = i / 20
            qpos = [t * 2, 0.7, 0.03 * math.sin(t * 8)] + [0.5 * math.sin(t * 8 + k) for k in range(6)]
            qvel = [2.0, 0.0, 0.24 * math.cos(t * 8)] + [4 * math.cos(t * 8 + k) for k in range(6)]
            exp.tracks("rollout/state").append(_ts=t, qpos=qpos, qvel=qvel, observation=qpos[1:] + qvel)
            exp.tracks("rollout/action").append(_ts=t, action=[math.tanh(v) for v in qpos[3:]], reward=2.0,
                                                 terminated=False, truncated=i == 59)
            frames.append(frame(t))
        exp.files("media", tags=["mock", "preview"]).save_image(frames[30], to="rollout-preview.png")
        exp.files("media", tags=["mock", "video"]).save_video(frames, to="policy-rollout.mp4", fps=20, codec="libx264")
        summary = {"mock": True, "best_eval_return": best_return, "best_update": best_update,
                   "total_env_steps": args.updates * 8192, "updates": args.updates,
                   "checkpoints": checkpoints, "track_frames": len(frames)}
        exp.files("checkpoints", tags=["best", "mock"]).save_json(
            {"mock": True, "loadable_training_checkpoint": False, "selected_update": best_update,
             "selection": "highest eval.return_mean", "eval_return": best_return}, to="best-policy.json")
        exp.files("reports").save_json(summary, to="summary.json")
        csv_text = io.StringIO()
        writer = csv.DictWriter(csv_text, fieldnames=list(evaluations[0]))
        writer.writeheader()
        writer.writerows(evaluations)
        exp.files("reports").save_text(csv_text.getvalue(), to="evaluation.csv")
        exp.files().save_text(readme + "\n## Final summary\n\n```json\n" + json.dumps(summary, indent=2) + "\n```\n", to="README.md")
        exp.logs.info("Synthetic training completed successfully", **summary)
        exp.flush()
        run_id = exp.id
    print(json.dumps({"prefix": prefix, "run_id": run_id, "status": "COMPLETED", **summary}, indent=2), flush=True)


if __name__ == "__main__":
    main()
