"""12장 · Dreamer — 그림만 보고, World Model 의 상상 속에서 행동을 배워 진자 세우기.

무엇을 하나
    1. 11장의 RSSM World Model 을 그대로 가져와 같은 방법으로 학습한다.
    2. 학습 데이터의 사후 상태에서 출발해 H=15 스텝을 '상상' 하고,
       상상 궤적의 λ-리턴으로 크리틱(가치)과 액터(정책)를 학습한다.
       액터는 World Model 을 거슬러 미분(역전파)해서 리턴을 키운다.
    3. 액터로 실제 환경에서 에피소드를 모으고 1 로 돌아간다. (계획(CEM)이 필요 없다!)
    4. 학습 곡선, 성공 에피소드, 상상 vs 진짜 그림을 저장한다.

실행
    python ch12_dreamer.py                       # 본문 결과 (노트북 GPU 혼자 약 45분. CPU 로는 하루 이상이라 GPU 권장)
    python ch12_dreamer.py --quick               # 연기 시험 (CPU 약 15초)
    python ch12_dreamer.py --return-norm         # DreamerV3 식 리턴 정규화를 켠다
    python ch12_dreamer.py --planet-log ch11_out/log.json   # 그래프에 11장 PlaNet 결과도 함께 그린다
"""

from __future__ import annotations

import argparse
import copy
import json
import math
import os
import time
from dataclasses import asdict, dataclass

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F

from ch11_rssm_planet import (
    Config,
    LatentAgent,
    ReplayBuffer,
    WorldModel,
    episode_figure,
    get_device,
    mlp,
    open_loop_figure,
    random_baseline,
    run_episode,
)
from wm_envs import PixelPendulum


# --8<-- [start:config]
@dataclass
class DreamerConfig(Config):
    # 11장의 Config(모델 크기 · 배치 · 자유 내트 등)를 물려받고, 행동 학습에 필요한 값만 더한다.
    imag_horizon: int = 15  # H: 상상 길이
    gamma: float = 0.99  # γ: 할인율
    lam: float = 0.95  # λ: λ-리턴의 섞는 비율
    actor_lr: float = 8e-5
    critic_lr: float = 8e-5
    ac_hidden: int = 300  # 액터 · 크리틱 MLP 너비
    ac_layers: int = 3
    entropy_scale: float = 1e-4  # η: 엔트로피 보너스
    init_std: float = 1.0  # 액터의 처음 표준편차 (tanh 앞)
    slow_critic_every: int = 100  # 목표(느린) 크리틱을 몇 번마다 복사할지 (DreamerV2)
    return_norm: bool = False  # DreamerV3 식 리턴 정규화
# --8<-- [end:config]


# --8<-- [start:actor]
class Actor(nn.Module):
    """tanh-가우시안 정책: u ~ N(μ, σ²), a = tanh(u) ∈ (-1, 1)."""

    def __init__(self, feat_dim, act_dim=1, hidden=300, layers=3, init_std=1.0, min_std=1e-4):
        super().__init__()
        self.net = mlp(feat_dim, hidden, 2 * act_dim, layers)
        self.raw_init_std = math.log(math.exp(init_std) - 1)  # softplus(raw) = init_std 가 되는 raw
        self.min_std = min_std

    def forward(self, feat):
        mean, std = self.net(feat).chunk(2, -1)
        mean = 5 * torch.tanh(mean / 5)  # 평균이 너무 커져 tanh 가 포화되지 않게 [-5, 5] 로 부드럽게 묶는다
        std = F.softplus(std + self.raw_init_std) + self.min_std
        return mean, std

    def sample(self, feat):
        """재매개변수화로 행동을 뽑고, 그 행동의 엔트로피 추정값도 함께 돌려준다."""
        mean, std = self(feat)
        eps = torch.randn_like(mean)
        u = mean + std * eps  # 기울기가 mean · std 로 흐른다
        a = torch.tanh(u)
        # H[a] = H[u] + E[log |da/du|],  log |da/du| = log(1 - tanh²(u))
        gauss_ent = (0.5 * math.log(2 * math.pi * math.e) + torch.log(std)).sum(-1)
        log_det = torch.log(1 - a.pow(2) + 1e-6).sum(-1)
        return a, gauss_ent + log_det

    def mode(self, feat):
        mean, _ = self(feat)
        return torch.tanh(mean)
# --8<-- [end:actor]


# --8<-- [start:lambda-return]
def lambda_return(rewards, values, gamma, lam):
    """λ-리턴을 뒤에서부터 재귀식으로 계산한다.

    rewards : (H, N)    r̂_0 … r̂_{H-1}   (r̂_t = 상태 s_{t+1} 에서 예측한, 전이 t 의 보상)
    values  : (H+1, N)  v(s_0) … v(s_H)
    반환    : (H, N)    V^λ_0 … V^λ_{H-1}
      V^λ_t = r̂_t + γ [ (1-λ) v(s_{t+1}) + λ V^λ_{t+1} ],   V^λ_H = v(s_H)
    """
    H = rewards.shape[0]
    g = values[H]  # V^λ_H = v(s_H)
    out = []
    for t in reversed(range(H)):
        g = rewards[t] + gamma * ((1 - lam) * values[t + 1] + lam * g)
        out.append(g)
    return torch.stack(out[::-1])
# --8<-- [end:lambda-return]


# --8<-- [start:lambda-check]
def lambda_return_by_definition(rewards, values, gamma, lam):
    """정의대로: n-스텝 리턴들을 (1-λ)λ^{n-1} 가중치로 섞는다 (마지막 것은 λ^{N-1})."""
    H = rewards.shape[0]
    out = []
    for t in range(H):
        N = H - t  # 남은 스텝 수

        def n_step(n):  # V^(n)_t = r̂_t + γ r̂_{t+1} + … + γ^{n-1} r̂_{t+n-1} + γ^n v(s_{t+n})
            return sum(gamma**k * rewards[t + k] for k in range(n)) + gamma**n * values[t + n]

        g = sum((1 - lam) * lam ** (n - 1) * n_step(n) for n in range(1, N)) + lam ** (N - 1) * n_step(N)
        out.append(g)
    return torch.stack(out)
# --8<-- [end:lambda-check]


class Dreamer:
    def __init__(self, cfg: DreamerConfig, device):
        self.cfg = cfg
        self.wm = WorldModel(cfg).to(device)
        f = self.wm.feat_dim
        self.actor = Actor(f, 1, cfg.ac_hidden, cfg.ac_layers, cfg.init_std).to(device)
        self.critic = mlp(f, cfg.ac_hidden, 1, cfg.ac_layers).to(device)
        self.slow_critic = copy.deepcopy(self.critic).requires_grad_(False)
        self.wm_opt = torch.optim.Adam(self.wm.parameters(), lr=cfg.lr, eps=cfg.eps)
        self.actor_opt = torch.optim.Adam(self.actor.parameters(), lr=cfg.actor_lr, eps=cfg.eps)
        self.critic_opt = torch.optim.Adam(self.critic.parameters(), lr=cfg.critic_lr, eps=cfg.eps)
        self.ret_scale = 1.0  # DreamerV3 리턴 정규화의 이동 평균
        self.steps = 0

    # --8<-- [start:imagine]
    def imagine(self, h, z):
        """사후 상태 (N, ·) 에서 출발해 액터로 H 스텝을 상상한다. 상태 · 엔트로피 목록을 돌려준다."""
        feats, ents = [self.wm.feat(h, z)], []
        for _ in range(self.cfg.imag_horizon):
            a, ent = self.actor.sample(feats[-1].detach())  # 액터 입력에서는 기울기를 끊는다 (sg)
            h, z, _, _ = self.wm.rssm.img_step(h, z, a)  # z ~ p(z | h) 도 재매개변수화로 뽑는다
            feats.append(self.wm.feat(h, z))
            ents.append(ent)
        return torch.stack(feats), torch.stack(ents)  # (H+1, N, F), (H, N)
    # --8<-- [end:imagine]

    # --8<-- [start:train-step]
    def train_step(self, batch):
        cfg = self.cfg
        # ① World Model: 11장과 똑같이 순차 ELBO 로 한 스텝
        wm_loss, metrics, states = self.wm.loss(batch)
        self.wm_opt.zero_grad(set_to_none=True)
        wm_loss.backward()
        nn.utils.clip_grad_norm_(self.wm.parameters(), cfg.grad_clip)
        self.wm_opt.step()

        # ② 상상: 배치의 모든 사후 상태 (B·L 개) 에서 출발. 출발점은 상수로 본다 (detach).
        h = states["h"].detach().reshape(-1, cfg.deter)
        z = states["z"].detach().reshape(-1, cfg.stoch)
        self.wm.requires_grad_(False)  # 액터 손실이 World Model 을 고치지 않게 얼린다 (기울기는 통과)
        feats, ents = self.imagine(h, z)
        rewards = self.wm.reward(feats[1:]).squeeze(-1)  # (H, N): r̂_t = R(s_{t+1})
        values = self.slow_critic(feats).squeeze(-1)  # (H+1, N): v(s_0..s_H)
        returns = lambda_return(rewards, values, cfg.gamma, cfg.lam)  # (H, N)
        self.wm.requires_grad_(True)

        # ③ 액터: λ-리턴을 키우는 쪽으로 (동역학을 거슬러 역전파) + 엔트로피 보너스
        if cfg.return_norm:  # DreamerV3: 리턴의 5–95 백분위 폭으로 나눈다 (1 보다 작으면 1)
            with torch.no_grad():
                q = torch.quantile(returns.flatten(), torch.tensor([0.05, 0.95], device=returns.device))
                self.ret_scale = 0.99 * self.ret_scale + 0.01 * (q[1] - q[0]).item()
            actor_obj = returns / max(1.0, self.ret_scale)
        else:
            actor_obj = returns
        actor_loss = -actor_obj.mean() - cfg.entropy_scale * ents.mean()
        self.actor_opt.zero_grad(set_to_none=True)
        actor_loss.backward()
        nn.utils.clip_grad_norm_(self.actor.parameters(), cfg.grad_clip)
        self.actor_opt.step()

        # ④ 크리틱: v(s_t) 를 λ-리턴(상수로 본다)에 맞춘다
        v = self.critic(feats[:-1].detach()).squeeze(-1)  # (H, N)
        critic_loss = 0.5 * ((v - returns.detach()) ** 2).mean()
        self.critic_opt.zero_grad(set_to_none=True)
        critic_loss.backward()
        nn.utils.clip_grad_norm_(self.critic.parameters(), cfg.grad_clip)
        self.critic_opt.step()

        # ⑤ 느린 크리틱: 일정 횟수마다 지금 크리틱을 복사 (목표값을 흔들리지 않게)
        self.steps += 1
        if self.steps % cfg.slow_critic_every == 0:
            self.slow_critic.load_state_dict(self.critic.state_dict())

        metrics.update(actor=actor_loss.item(), critic=critic_loss.item(),
                       imag_return=returns.mean().item(), entropy=ents.mean().item())
        return metrics
    # --8<-- [end:train-step]


def curves_figure(log, path, random_return, planet=None):
    import matplotlib

    matplotlib.use("Agg")
    import matplotlib.pyplot as plt

    fig, axes = plt.subplots(1, 2, figsize=(10, 3.4))
    ax = axes[0]
    ax.plot(log["train_steps_env"], log["train_return"], ".", color="#9aa8b4", ms=4, label="Dreamer collect (noise)")
    ax.plot(log["eval_steps_env"], log["eval_return"], "o-", color="#1f8a5b", label="Dreamer eval")
    if planet is not None:
        ax.plot(planet["eval_steps_env"], planet["eval_return"], "s--", color="#2f6fdb", ms=4, label="PlaNet eval (ch11)")
    ax.axhline(random_return, color="#b03a6a", ls="--", label="random policy")
    ax.set_xlabel("environment steps")
    ax.set_ylabel("episode return (200 steps)")
    ax.set_title("return", fontsize=10)
    ax.legend(fontsize=8)
    ax = axes[1]
    it = np.arange(len(log["imag_return"]))
    ax.plot(it, log["imag_return"], color="#1f8a5b", label="mean imagined lambda-return")
    ax.set_xlabel("iteration (100 train steps each)")
    ax.set_ylabel("lambda-return (scaled reward)")
    ax2 = ax.twinx()
    ax2.plot(it, log["critic"], color="#b7620c", alpha=0.7, label="critic loss")
    ax2.set_yscale("log")
    ax2.set_ylabel("critic loss")
    lines = ax.get_legend_handles_labels()[0] + ax2.get_legend_handles_labels()[0]
    labels = ax.get_legend_handles_labels()[1] + ax2.get_legend_handles_labels()[1]
    ax.legend(lines, labels, fontsize=8, loc="lower right")
    ax.set_title("actor-critic in imagination", fontsize=10)
    fig.tight_layout()
    fig.savefig(path, dpi=110, facecolor="white")
    plt.close(fig)


# --8<-- [start:main]
def main():
    p = argparse.ArgumentParser()
    p.add_argument("--quick", action="store_true")
    p.add_argument("--iterations", type=int, default=None)
    p.add_argument("--batch-size", type=int, default=None)
    p.add_argument("--return-norm", action="store_true", help="DreamerV3 식 리턴 정규화")
    p.add_argument("--planet-log", default=None, help="11장 log.json 경로 (그래프 비교용)")
    p.add_argument("--fig-dir", default="figures")
    p.add_argument("--out", default="ch12_out")
    p.add_argument("--seed", type=int, default=0)
    args = p.parse_args()

    cfg = DreamerConfig()
    if args.quick:
        cfg = DreamerConfig(seed_episodes=2, iterations=2, train_steps=5, batch_size=8, seq_len=20,
                            imag_horizon=5, eval_every=2, eval_episodes=1)
    if args.iterations is not None:
        cfg.iterations = args.iterations
    if args.batch_size is not None:
        cfg.batch_size = args.batch_size
    cfg.return_norm = args.return_norm
    torch.manual_seed(args.seed)
    rng = np.random.default_rng(args.seed)
    device = get_device()
    torch.backends.cudnn.benchmark = True
    os.makedirs(args.fig_dir, exist_ok=True)
    os.makedirs(args.out, exist_ok=True)
    print(f"device={device}", asdict(cfg))

    # λ-리턴: 재귀식 = 정의 인지 숫자로 확인
    r, v = torch.randn(6, 4), torch.randn(7, 4)
    diff = (lambda_return(r, v, 0.9, 0.7) - lambda_return_by_definition(r, v, 0.9, 0.7)).abs().max()
    print(f"lambda-return check: recursion vs definition max |diff| = {diff:.2e}")

    env = PixelPendulum(seed=args.seed, action_repeat=cfg.action_repeat)
    buffer = ReplayBuffer(device)
    for _ in range(cfg.seed_episodes):
        buffer.add(run_episode(env, None, rng=rng))
    random_return = random_baseline(cfg, args.seed, episodes=3 if args.quick else 10)
    print(f"random policy return: {random_return:.1f}")

    agent = Dreamer(cfg, device)
    collect = LatentAgent(agent.wm, lambda h, z: agent.actor.sample(agent.wm.feat(h, z))[0])
    greedy = LatentAgent(agent.wm, lambda h, z: agent.actor.mode(agent.wm.feat(h, z)))

    keys = ("recon", "reward", "kl", "actor", "critic", "imag_return", "entropy")
    log = {k: [] for k in keys + ("train_return", "train_steps_env", "eval_return", "eval_steps_env", "act_ms")}
    start = time.time()
    for it in range(1, cfg.iterations + 1):
        ms = [agent.train_step(buffer.sample(cfg.batch_size, cfg.seq_len, rng)) for _ in range(cfg.train_steps)]
        t0 = time.time()
        ep = run_episode(env, collect, explore_noise=cfg.explore_noise)
        act_ms = (time.time() - t0) / len(ep["action"]) * 1000
        buffer.add(ep)
        for k in keys:
            log[k].append(float(np.mean([m[k] for m in ms])))
        log["train_return"].append(float(ep["reward"].sum()))
        log["train_steps_env"].append(buffer.num_steps * cfg.action_repeat)
        log["act_ms"].append(act_ms)
        msg = (f"it {it:3d} | env steps {buffer.num_steps * cfg.action_repeat:6d} | recon {log['recon'][-1]:6.1f} "
               f"kl {log['kl'][-1]:4.2f} | imag G {log['imag_return'][-1]:7.2f} critic {log['critic'][-1]:6.3f} "
               f"ent {log['entropy'][-1]:5.2f} | return {ep['reward'].sum():8.1f} | act {act_ms:4.1f} ms "
               f"| {time.time() - start:5.0f}s")
        if it % cfg.eval_every == 0 or it == cfg.iterations:
            rets = [run_episode(env, greedy)["reward"].sum() for _ in range(cfg.eval_episodes)]
            log["eval_return"].append(float(np.mean(rets)))
            log["eval_steps_env"].append(buffer.num_steps * cfg.action_repeat)
            msg += f" | eval {np.mean(rets):8.1f}"
        print(msg, flush=True)

    torch.save(dict(wm=agent.wm.state_dict(), actor=agent.actor.state_dict(), critic=agent.critic.state_dict()),
               os.path.join(args.out, "dreamer.pt"))
    planet = None
    if args.planet_log and os.path.exists(args.planet_log):
        with open(args.planet_log) as f:
            planet = json.load(f)["log"]

    # 최종 평가: 처음 보는 시작 상태 10 개
    test_env = PixelPendulum(seed=args.seed + 123, action_repeat=cfg.action_repeat)
    final = [run_episode(test_env, greedy)["reward"].sum() for _ in range(3 if args.quick else 10)]
    print(f"final eval over {len(final)} episodes: mean {np.mean(final):.1f}, std {np.std(final):.1f}, "
          f"min {np.min(final):.1f}, max {np.max(final):.1f}")
    with open(os.path.join(args.out, "log.json"), "w") as f:
        json.dump(dict(log=log, random_return=random_return, final=[float(x) for x in final],
                       config=asdict(cfg)), f)

    curves_figure(log, os.path.join(args.fig_dir, "ch12-curves.png"), random_return, planet)
    ep = run_episode(test_env, greedy, record=True)
    episode_figure(ep, os.path.join(args.fig_dir, "ch12-dreamer-episode.png"),
                   title=f"Dreamer policy (no planning), return {ep['reward'].sum():.0f}")
    open_loop_figure(agent.wm, ep, os.path.join(args.fig_dir, "ch12-imagination.png"))
    print(f"done in {time.time() - start:.0f}s")
# --8<-- [end:main]


if __name__ == "__main__":
    main()
