"""5장 실습: 강화학습 기초.

  1. 할인 리턴 계산 (뒤에서부터 한 번에)
  2. 가치 반복: 2×3 작은 격자(손계산 확인) → 5×5 미끄러운 격자     → figures/ch05-gridworld.png
  3. 정책 경사(REINFORCE): 1차원 복도, 기준선 있음 · 없음 비교      → figures/ch05-reinforce.png
  4. 진자에서 세 가지 정책(무작위 · 가만히 · 손으로 만든 정책)의 리턴  → figures/ch05-pendulum-baselines.png
     (이 숫자가 6 · 7장에서 World Model 로 만든 계획기와 비교할 기준선이 된다)

실행:
    python ch05_rl_basics.py           # 전체 (노트북 CPU 에서 약 10~20초)
    python ch05_rl_basics.py --quick   # 축소판
numpy · matplotlib 만 쓴다 (torch 는 쓰지 않는다). 같은 폴더에 wm_envs.py 가 있어야 한다.
"""

from __future__ import annotations

import argparse
import os
import time

import matplotlib

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

from wm_envs import Pendulum


# ─────────────────────────────────────────────────────────────
# 1. 할인 리턴
# ─────────────────────────────────────────────────────────────

# --8<-- [start:returns]
def discounted_returns(rewards, gamma):
    """G_t = r_t + γ·G_{t+1} 를 뒤에서부터 계산한다. 결과는 rewards 와 길이가 같다."""
    G = np.zeros(len(rewards))
    running = 0.0  # 에피소드가 끝난 뒤의 리턴은 0
    for t in reversed(range(len(rewards))):
        running = rewards[t] + gamma * running
        G[t] = running
    return G
# --8<-- [end:returns]


def part1_returns(args):
    print("\n[1] 할인 리턴")
    # --8<-- [start:returns_demo]
    rewards = [1.0, 0.0, 0.0, 5.0]
    G = discounted_returns(rewards, gamma=0.9)
    print("보상        :", rewards)
    print("리턴 G_t    :", np.round(G, 4).tolist())
    # 직접 더한 값과 같은지: G_0 = 1 + 0.9·0 + 0.9²·0 + 0.9³·5
    print("G_0 직접 계산:", 1 + 0.9 * 0 + 0.9**2 * 0 + 0.9**3 * 5)

    # 보상 1 을 끝없이 받으면 리턴은 1/(1−γ) 에 가까워진다
    for gamma in [0.9, 0.99]:
        G_long = discounted_returns(np.ones(5000), gamma)[0]
        print(f"γ={gamma}: 보상 1 을 5000번 받은 리턴 = {G_long:.4f},  1/(1−γ) = {1 / (1 - gamma):.4f}")
    # --8<-- [end:returns_demo]


# ─────────────────────────────────────────────────────────────
# 2. 가치 반복
# ─────────────────────────────────────────────────────────────

ACTIONS = {"up": (-1, 0), "down": (1, 0), "left": (0, -1), "right": (0, 1)}
ARROWS = {"up": "↑", "down": "↓", "left": "←", "right": "→"}


# --8<-- [start:grid]
class GridWorld:
    """격자 세계. layout 의 글자: '.' 빈 칸, '#' 벽, 'G' 목표(+1, 끝), 'P' 구덩이(−1, 끝).

    slip: 행동이 의도와 다르게 옆(직각) 방향으로 미끄러질 확률 (양옆 반씩).
    step_reward: 끝 칸이 아닌 곳으로 움직일 때마다 받는 보상 (예: −0.02 = 서두르라는 뜻).
    """

    def __init__(self, layout, slip=0.0, step_reward=0.0):
        self.layout = [list(row) for row in layout]
        self.rows, self.cols = len(layout), len(layout[0])
        self.slip = slip
        self.step_reward = step_reward
        self.states = [(r, c) for r in range(self.rows) for c in range(self.cols) if self.layout[r][c] != "#"]

    def is_terminal(self, s):
        return self.layout[s[0]][s[1]] in "GP"

    def move(self, s, delta):
        r, c = s[0] + delta[0], s[1] + delta[1]
        if not (0 <= r < self.rows and 0 <= c < self.cols) or self.layout[r][c] == "#":
            return s  # 벽이나 바깥으로는 못 간다: 제자리
        return (r, c)

    def transitions(self, s, a):
        """[(확률, 다음 상태, 보상), ...]  = 환경의 규칙 p(s', r | s, a)."""
        dr, dc = ACTIONS[a]
        outcomes = [(1.0 - self.slip, (dr, dc))]
        if self.slip > 0:
            outcomes += [(self.slip / 2, (dc, dr)), (self.slip / 2, (-dc, -dr))]  # 직각 방향 두 개
        result = []
        for p, delta in outcomes:
            s2 = self.move(s, delta)
            cell = self.layout[s2[0]][s2[1]]
            r = 1.0 if cell == "G" else (-1.0 if cell == "P" else self.step_reward)
            result.append((p, s2, r))
        return result
# --8<-- [end:grid]


# --8<-- [start:value_iteration]
def value_iteration(env, gamma, n_iters=1000, tol=1e-8, labels=None):
    """V_{k+1}(s) = max_a Σ_{s'} p(s'|s,a)·[r + γ·V_k(s')]  를 값이 더 바뀌지 않을 때까지 되풀이한다."""
    V = {s: 0.0 for s in env.states}  # V_0 = 0
    for k in range(n_iters):
        V_new = {}
        for s in env.states:
            if env.is_terminal(s):
                V_new[s] = 0.0  # 끝 칸 뒤에는 아무 보상도 없다
                continue
            q_values = [sum(p * (r + gamma * V[s2]) for p, s2, r in env.transitions(s, a)) for a in ACTIONS]
            V_new[s] = max(q_values)  # 가장 좋은 행동의 값
        delta = max(abs(V_new[s] - V[s]) for s in env.states)
        V = V_new
        if labels:  # 칸 이름을 주면 반복마다 값을 찍는다
            print(f"  반복 {k + 1}: " + "  ".join(f"{labels[s]}={V[s]:.3f}" for s in env.states))
        if delta < tol:
            break
    # 탐욕 정책: 각 칸에서 가장 큰 Q 를 주는 행동
    policy = {}
    for s in env.states:
        if not env.is_terminal(s):
            q = {a: sum(p * (r + gamma * V[s2]) for p, s2, r in env.transitions(s, a)) for a in ACTIONS}
            policy[s] = max(q, key=q.get)
    return V, policy, k + 1
# --8<-- [end:value_iteration]


def part2_gridworld(args):
    print("\n[2] 가치 반복")
    # --8<-- [start:tiny_grid]
    tiny = GridWorld(["..G",
                      "..."])  # 위 줄: A B G,  아래 줄: C D E  (본문의 그림과 같다)
    names = {(0, 0): "A", (0, 1): "B", (0, 2): "G", (1, 0): "C", (1, 1): "D", (1, 2): "E"}
    V, policy, iters = value_iteration(tiny, gamma=0.9, labels=names)
    print("  탐욕 정책:", {names[s]: ARROWS[a] for s, a in policy.items()})
    # --8<-- [end:tiny_grid]

    # --8<-- [start:big_grid]
    big = GridWorld(["....G",
                     ".##.P",
                     ".....",
                     ".#.#.",
                     "....."], slip=0.2, step_reward=-0.02)
    V, policy, iters = value_iteration(big, gamma=0.95)
    print(f"  5×5 미끄러운 격자: {iters}번 반복 만에 수렴")
    for r in range(big.rows):
        row = []
        for c in range(big.cols):
            cell = big.layout[r][c]
            row.append("  ##  " if cell == "#" else (f"  {cell}   " if cell in "GP" else f"{V[(r, c)]:+.3f}"))
        print("   " + " ".join(row))
    # --8<-- [end:big_grid]

    fig, ax = plt.subplots(figsize=(5.2, 4.6))
    grid = np.full((big.rows, big.cols), np.nan)
    for s in big.states:
        if not big.is_terminal(s):
            grid[s] = V[s]
    im = ax.imshow(grid, cmap="viridis")
    for r in range(big.rows):
        for c in range(big.cols):
            cell = big.layout[r][c]
            if cell == "#":
                ax.add_patch(plt.Rectangle((c - 0.5, r - 0.5), 1, 1, color="#444444"))
            elif cell in "GP":
                ax.add_patch(plt.Rectangle((c - 0.5, r - 0.5), 1, 1, color="#31a354" if cell == "G" else "#d94801"))
                ax.text(c, r, "+1" if cell == "G" else "-1", ha="center", va="center", color="white", fontsize=13, weight="bold")
            else:
                dr, dc = ACTIONS[policy[(r, c)]]
                ax.annotate("", xy=(c + 0.3 * dc, r + 0.3 * dr), xytext=(c - 0.3 * dc, r - 0.3 * dr),
                            arrowprops=dict(arrowstyle="->", color="white", lw=1.6))
                ax.text(c, r + 0.38, f"{V[(r, c)]:.2f}", ha="center", va="center", color="white", fontsize=7)
    ax.set_xticks([])
    ax.set_yticks([])
    ax.set_title("Value iteration: V*(s) and greedy policy\n(slip=0.2, step reward=-0.02, gamma=0.95)", fontsize=9)
    fig.colorbar(im, ax=ax, fraction=0.046)
    fig.tight_layout()
    fig.savefig(os.path.join(args.fig_dir, "ch05-gridworld.png"), dpi=120)
    plt.close(fig)


# ─────────────────────────────────────────────────────────────
# 3. REINFORCE: 1차원 복도
# ─────────────────────────────────────────────────────────────

# --8<-- [start:corridor]
class Corridor:
    """칸 0 ~ 4 의 복도. 칸 0 에서 시작해 칸 4(목표)에 닿으면 보상 +1 을 받고 끝난다.
    행동 0 = 왼쪽, 1 = 오른쪽. 15 스텝 안에 못 닿으면 보상 0 으로 끝난다."""

    n_states, n_actions, goal, max_steps = 5, 2, 4, 15

    def __init__(self, rng):
        self.rng = rng

    def reset(self):
        self.s, self.t = 0, 0
        return self.s

    def step(self, a):
        self.s = max(0, self.s - 1) if a == 0 else self.s + 1
        self.t += 1
        if self.s == self.goal:
            return self.s, 1.0, True
        return self.s, 0.0, self.t >= self.max_steps


def softmax(x):
    e = np.exp(x - x.max())
    return e / e.sum()
# --8<-- [end:corridor]


# --8<-- [start:reinforce]
def run_episode(env, logits, rng):
    """정책 π(a|s) = softmax(logits[s]) 로 에피소드 하나를 돈다."""
    s, done = env.reset(), False
    states, actions, rewards = [], [], []
    while not done:
        a = rng.choice(2, p=softmax(logits[s]))
        s2, r, done = env.step(a)
        states.append(s), actions.append(a), rewards.append(r)
        s = s2
    return states, actions, rewards


def grad_log_pi(logits, s, a):
    """∇_logits log π(a|s). 소프트맥스 정책이면 (원-핫(a) − π(·|s)) 가 s 행에만 생긴다."""
    g = np.zeros_like(logits)
    g[s] = -softmax(logits[s])
    g[s, a] += 1.0
    return g


def reinforce(n_episodes, gamma, lr, use_baseline, seed):
    rng = np.random.default_rng(seed)
    env = Corridor(rng)
    logits = np.zeros((env.n_states, env.n_actions))  # 처음엔 왼쪽 · 오른쪽 반반
    V = np.zeros(env.n_states)  # 기준선 b(s): 상태별 리턴의 이동 평균
    returns = []
    for _ in range(n_episodes):
        states, actions, rewards = run_episode(env, logits, rng)
        G = discounted_returns(rewards, gamma)  # 각 시각의 리턴 G_t
        grad = np.zeros_like(logits)
        for s, a, g_t in zip(states, actions, G):
            b = V[s] if use_baseline else 0.0
            grad += (g_t - b) * grad_log_pi(logits, s, a)  # (G_t − b)·∇log π(a_t|s_t)
            if use_baseline:
                V[s] += 0.1 * (g_t - V[s])  # 기준선도 조금씩 리턴 쪽으로
        logits += lr * grad  # 경사 '상승': 리턴을 키우는 방향
        returns.append(G[0])
    return np.array(returns), logits
# --8<-- [end:reinforce]


# --8<-- [start:bandit]
def bandit_reinforce(steps, lr, use_baseline, seed, means=(10.0, 11.0)):
    """팔 두 개짜리 밴딧. 보상 ~ N(10, 1) 또는 N(11, 1). 모든 보상에 큰 공통 값(약 10)이 섞여 있다."""
    rng = np.random.default_rng(seed)
    logits = np.zeros(2)
    b = None  # 기준선: 받은 보상의 이동 평균
    history = []
    for _ in range(steps):
        p = softmax(logits)
        a = rng.choice(2, p=p)
        r = rng.normal(means[a], 1.0)
        if b is None:
            b = r
        g = -p
        g[a] += 1.0  # ∇ log π(a)
        logits += lr * (r - (b if use_baseline else 0.0)) * g
        b += 0.05 * (r - b)
        history.append(softmax(logits)[1])  # 좋은 팔(1)을 고를 확률
    return np.array(history)
# --8<-- [end:bandit]


def part3_reinforce(args):
    print("\n[3] REINFORCE: 1차원 복도 · 밴딧")
    gamma, lr = 0.9, 0.1
    n_ep = 100 if args.quick else 400
    n_seeds = 5 if args.quick else 30

    # --8<-- [start:variance]
    # 처음 정책(반반)에서 기울기 추정값을 많이 뽑아, 기준선이 있을 때와 없을 때의 평균 · 분산을 비교한다.
    rng = np.random.default_rng(args.seed)
    env = Corridor(rng)
    logits0 = np.zeros((5, 2))
    episodes = [run_episode(env, logits0, rng) for _ in range(4000)]
    # 기준선 b(s) = 그 상태에서 받은 리턴의 평균 (몬테카를로로 추정)
    sums, counts = np.zeros(5), np.zeros(5)
    for states, _, rewards in episodes:
        for s, g in zip(states, discounted_returns(rewards, gamma)):
            sums[s] += g
            counts[s] += 1
    b = sums / np.maximum(counts, 1)
    for name, base in [("기준선 없음", np.zeros(5)), ("기준선 b(s)", b)]:
        grads = []
        for states, actions, rewards in episodes:
            G = discounted_returns(rewards, gamma)
            grads.append(sum((g - base[s]) * grad_log_pi(logits0, s, a) for s, a, g in zip(states, actions, G)))
        grads = np.array(grads)  # (4000, 5, 2)
        print(f"  {name}: 기울기 평균(칸0,오른쪽) = {grads[:, 0, 1].mean():+.4f},  분산 합 = {grads.var(axis=0).sum():.4f}")
    # --8<-- [end:variance]

    curves = {}
    for use_b in [False, True]:
        runs = [reinforce(n_ep, gamma, lr, use_b, seed=args.seed + k)[0] for k in range(n_seeds)]
        curves[use_b] = np.array(runs)
        last = curves[use_b][:, -50:].mean()
        print(f"  복도 {'기준선 있음' if use_b else '기준선 없음'}: 마지막 50 에피소드 평균 리턴 {last:.3f}  (최적 = 0.9³ = {0.9**3:.3f})")
    _, logits = reinforce(n_ep, gamma, lr, True, seed=args.seed)
    print("  학습 뒤 π(오른쪽|s):", np.round([softmax(l)[1] for l in logits[:4]], 3).tolist())

    print("  밴딧(보상 평균 10 vs 11): 기준선의 효과")
    n_bandit_seeds = 10 if args.quick else 50
    bandit = {}
    for use_b in [False, True]:
        P = np.array([bandit_reinforce(1000, 0.05, use_b, seed=args.seed + k) for k in range(n_bandit_seeds)])
        bandit[use_b] = P
        print(f"  밴딧 {'기준선 있음' if use_b else '기준선 없음'}: 1000 스텝 뒤 π(좋은 팔) 평균 {P[:, -1].mean():.3f},"
              f"  나쁜 팔로 굳은 시드 {(P[:, -1] < 0.5).mean() * 100:.0f}%")

    fig, axes = plt.subplots(1, 2, figsize=(10, 3.6))
    ax = axes[0]
    k = 20
    m = curves[True].mean(0)
    sm = np.convolve(m, np.ones(k) / k, mode="valid")
    ax.plot(np.arange(len(sm)) + k - 1, sm, color="#2171b5", lw=2, label="REINFORCE (with baseline)")
    ax.axhline(0.9**3, color="k", ls="--", lw=0.8, label="optimal return 0.9^3")
    ax.set_xlabel("episode")
    ax.set_ylabel(f"return (mean of {n_seeds} seeds)")
    ax.set_title("1-D corridor: learning to walk right")
    ax.legend(fontsize=8)
    ax = axes[1]
    for use_b, c in [(False, "#d94801"), (True, "#2171b5")]:
        for run in bandit[use_b][:15]:
            ax.plot(run, color=c, lw=0.5, alpha=0.25)
        ax.plot(bandit[use_b].mean(0), color=c, lw=2.2, label="with baseline" if use_b else "no baseline")
    ax.set_xlabel("step")
    ax.set_ylabel("pi(better arm)")
    ax.set_title("Bandit with rewards ~10 vs ~11")
    ax.legend(fontsize=8)
    fig.tight_layout()
    fig.savefig(os.path.join(args.fig_dir, "ch05-reinforce.png"), dpi=110)
    plt.close(fig)


# ─────────────────────────────────────────────────────────────
# 4. 진자: 세 가지 정책
# ─────────────────────────────────────────────────────────────

# --8<-- [start:policies]
def random_policy(obs, rng):
    return rng.uniform(-2.0, 2.0, size=1)


def zero_policy(obs, rng):
    return np.zeros(1)


def energy_pd_policy(obs, rng=None, k_energy=1.0, kp=10.0, kd=2.0, switch_cos=0.9):
    """손으로 만든 정책: 아래에서는 에너지를 펌프질하고, 위 근처에서는 PD 제어로 균형을 잡는다."""
    cos_th, sin_th, thdot = obs
    th = np.arctan2(sin_th, cos_th)  # [-π, π], 0 = 똑바로 선 자세
    if cos_th > switch_cos:  # 위에서 약 ±26° 안: PD 제어
        u = -kp * th - kd * thdot  # 기울어진 반대쪽으로, 도는 반대쪽으로 민다
    else:  # 그 밖: 에너지 펌핑
        inertia = 1.0 / 3.0  # I = m l² / 3  (m = l = 1)
        energy = 0.5 * inertia * thdot**2 + 5.0 * np.cos(th)  # E = ½Iθ̇² + (mgl/2)·cos θ
        direction = 1.0 if thdot >= 0 else -1.0  # 도는 방향으로 밀면 에너지가 늘어난다 (dE/dt = θ̇·u)
        u = k_energy * (5.0 - energy) * direction  # 목표 에너지 mgl/2 = 5 와의 차이만큼
    return np.clip(np.array([u]), -2.0, 2.0)
# --8<-- [end:policies]


# --8<-- [start:evaluate]
def evaluate(policy, n_episodes, seed):
    env = Pendulum(seed=seed)
    rng = np.random.default_rng(seed)
    totals = []
    for _ in range(n_episodes):
        obs, done, total = env.reset(), False, 0.0
        while not done:
            obs, r, done = env.step(policy(obs, rng))
            total += r
        totals.append(total)
    return np.array(totals)
# --8<-- [end:evaluate]


def rollout_from_bottom(policy, seed=0):
    env = Pendulum(seed=seed)
    env.reset()
    env.th, env.thdot = np.pi, 0.0  # 아래에 가만히 매달린 상태에서 시작
    obs = env._obs()
    rng = np.random.default_rng(seed)
    ths, us = [], []
    done = False
    while not done:
        u = policy(obs, rng)
        ths.append(np.cos(env.th))  # 막대 끝의 높이: +1 = 똑바로 섬, −1 = 매달림
        us.append(float(u[0]))
        obs, _, done = env.step(u)
    return np.array(ths), np.array(us)


def part4_pendulum(args):
    print("\n[4] 진자: 세 가지 정책의 리턴 (할인 없이 200 스텝 보상 합)")
    n = 10 if args.quick else 100
    results = {}
    for name, pol in [("random", random_policy), ("zero torque", zero_policy), ("energy + PD", energy_pd_policy)]:
        R = evaluate(pol, n, seed=args.seed)
        results[name] = R
        print(f"  {name:12s}: 평균 {R.mean():8.1f}  표준편차 {R.std():6.1f}  최소 {R.min():8.1f}  최대 {R.max():8.1f}  ({n} 에피소드)")

    fig, axes = plt.subplots(1, 2, figsize=(10, 3.6), gridspec_kw=dict(width_ratios=[1.6, 1]))
    ax = axes[0]
    t = np.arange(200) * 0.05
    for (name, pol), c in zip([("random", random_policy), ("zero torque", zero_policy), ("energy + PD", energy_pd_policy)],
                              ["#999999", "#9ecae1", "#d94801"]):
        ths, _ = rollout_from_bottom(pol)
        ax.plot(t, ths, color=c, lw=1.8, label=name)
    ax.axhline(1, color="k", lw=0.6, ls="--")
    ax.set_xlabel("time (s)")
    ax.set_ylabel("cos(angle): +1 upright, -1 hanging")
    ax.set_title("Starting from hanging down")
    ax.legend(fontsize=8)
    ax = axes[1]
    names = list(results)
    ax.bar(names, [results[k].mean() for k in names], yerr=[results[k].std() for k in names],
           color=["#999999", "#9ecae1", "#d94801"], capsize=4)
    ax.set_ylabel("episode return (200 steps)")
    ax.set_title(f"Mean return over {n} episodes")
    ax.tick_params(axis="x", labelsize=8)
    fig.tight_layout()
    fig.savefig(os.path.join(args.fig_dir, "ch05-pendulum-baselines.png"), dpi=110)
    plt.close(fig)


def main():
    parser = argparse.ArgumentParser(description="5장: 강화학습 기초")
    parser.add_argument("--quick", action="store_true")
    parser.add_argument("--fig-dir", default="figures")
    parser.add_argument("--seed", type=int, default=0)
    args = parser.parse_args()
    os.makedirs(args.fig_dir, exist_ok=True)
    t0 = time.time()
    part1_returns(args)
    part2_gridworld(args)
    part3_reinforce(args)
    part4_pendulum(args)
    print(f"\n전체 {time.time() - t0:.1f}초")


if __name__ == "__main__":
    main()
