import argparse
import os
import time
from dataclasses import dataclass
from typing import Tuple, Dict, List

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.distributions import Categorical

from ragen.env.sokoban.env import SokobanEnv
from ragen.env.sokoban.config import SokobanEnvConfig
from ragen.utils import all_seed


# ===== Observation parsing (text grid -> 7xHxW one-hot) =====
SYMBOLS = ["#", "_", "O", "√", "X", "P", "S"]
SYMBOL_TO_IDX: Dict[str, int] = {s: i for i, s in enumerate(SYMBOLS)}


def parse_grid_text(obs_text: str, board_shape: Tuple[int, int]) -> torch.Tensor:
    lines = obs_text.splitlines()
    H, W = board_shape
    assert len(lines) == H, f"Grid height mismatch: expected {H}, got {len(lines)}"
    grid = [[c for c in line] for line in lines]
    assert all(len(row) == W for row in grid), "Grid width mismatch"
    out = np.zeros((len(SYMBOLS), H, W), dtype=np.float32)
    for r in range(H):
        for c in range(W):
            ch = grid[r][c]
            idx = SYMBOL_TO_IDX.get(ch, None)
            if idx is None:
                raise ValueError(f"Unknown grid symbol '{ch}' at {(r, c)}")
            out[idx, r, c] = 1.0
    return torch.from_numpy(out)


# ===== Small CNN Policy-Value Net =====
class SmallSokobanCNN(nn.Module):
    def __init__(self, in_channels: int, num_actions: int):
        super().__init__()
        # 6x6 is tiny; use minimal convs
        self.encoder = nn.Sequential(
            nn.Conv2d(in_channels, 32, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.ReLU(inplace=True),
            nn.Flatten(),
        )
        # compute flat size for 6x6 grids at runtime
        self._feat_dim = None
        self.policy_head = nn.Linear(64 * 6 * 6, num_actions)
        self.value_head = nn.Linear(64 * 6 * 6, 1)

    def forward(self, x: torch.Tensor):
        # x: [B, C, H, W]
        z = self.encoder(x)
        logits = self.policy_head(z)
        value = self.value_head(z).squeeze(-1)
        return logits, value


@dataclass
class PPOConfig:
    total_steps: int = 200_000
    rollout_steps: int = 256
    batch_size: int = 256
    update_epochs: int = 4
    gamma: float = 0.99
    gae_lambda: float = 0.95
    clip_coef: float = 0.2
    ent_coef: float = 0.01
    vf_coef: float = 0.5
    max_grad_norm: float = 0.5
    lr: float = 2.5e-4
    device: str = "cpu"


def compute_gae(rewards, dones, values, next_value, cfg: PPOConfig):
    T = len(rewards)
    adv = np.zeros(T, dtype=np.float32)
    lastgaelam = 0.0
    for t in reversed(range(T)):
        nonterminal = 1.0 - float(dones[t])
        delta = rewards[t] + cfg.gamma * next_value * nonterminal - values[t]
        lastgaelam = delta + cfg.gamma * cfg.gae_lambda * nonterminal * lastgaelam
        adv[t] = lastgaelam
        next_value = values[t]
    returns = adv + values
    return adv, returns


def collect_rollout(env: SokobanEnv, policy: SmallSokobanCNN, cfg: PPOConfig, board_shape: Tuple[int, int], device: str):
    obs_buf = []
    act_buf = []
    logp_buf = []
    rew_buf = []
    done_buf = []
    val_buf = []

    policy.eval()

    obs_text = env.render()  # current text observation
    for _ in range(cfg.rollout_steps):
        obs_t = parse_grid_text(obs_text, board_shape).unsqueeze(0).to(device)
        with torch.no_grad():
            logits, value = policy(obs_t)
            dist = Categorical(logits=logits)
            act_model = dist.sample()[0].item()  # 0..3
            logp = dist.log_prob(torch.tensor([act_model], device=device)).item()
            val = value[0].item()
        act_env = act_model + 1  # map to 1..4
        next_obs_text, reward, done, _ = env.step(act_env)

        obs_buf.append(obs_t.squeeze(0).cpu().numpy())
        act_buf.append(act_model)
        logp_buf.append(logp)
        rew_buf.append(reward)
        done_buf.append(done)
        val_buf.append(val)

        obs_text = next_obs_text
        if done:
            obs_text = env.reset()

    # bootstrap value
    with torch.no_grad():
        obs_t = parse_grid_text(obs_text, board_shape).unsqueeze(0).to(device)
        _, next_value = policy(obs_t)
        next_value = next_value[0].item()

    adv, ret = compute_gae(
        np.array(rew_buf, dtype=np.float32),
        np.array(done_buf, dtype=np.bool_),
        np.array(val_buf, dtype=np.float32),
        next_value,
        cfg,
    )

    data = {
        "obs": torch.from_numpy(np.stack(obs_buf)).to(device),
        "actions": torch.tensor(act_buf, dtype=torch.long, device=device),
        "logp": torch.tensor(logp_buf, dtype=torch.float32, device=device),
        "advantages": torch.tensor(adv, dtype=torch.float32, device=device),
        "returns": torch.tensor(ret, dtype=torch.float32, device=device),
        "values": torch.tensor(val_buf, dtype=torch.float32, device=device),
    }
    return data


def ppo_update(policy, optimizer, data, cfg: PPOConfig):
    policy.train()
    obs = data["obs"]
    actions = data["actions"]
    old_logp = data["logp"]
    advantages = data["advantages"]
    returns = data["returns"]

    advantages = (advantages - advantages.mean()) / (advantages.std() + 1e-8)

    N = obs.shape[0]
    idxs = np.arange(N)

    for _ in range(cfg.update_epochs):
        np.random.shuffle(idxs)
        for start in range(0, N, cfg.batch_size):
            end = start + cfg.batch_size
            mb_idx = idxs[start:end]
            mb_obs = obs[mb_idx]
            mb_act = actions[mb_idx]
            mb_old_logp = old_logp[mb_idx]
            mb_adv = advantages[mb_idx]
            mb_ret = returns[mb_idx]

            logits, values = policy(mb_obs)
            dist = Categorical(logits=logits)
            new_logp = dist.log_prob(mb_act)
            entropy = dist.entropy().mean()

            ratio = (new_logp - mb_old_logp).exp()
            pg_loss1 = -mb_adv * ratio
            pg_loss2 = -mb_adv * torch.clamp(ratio, 1.0 - cfg.clip_coef, 1.0 + cfg.clip_coef)
            pg_loss = torch.max(pg_loss1, pg_loss2).mean()

            v_loss = 0.5 * (mb_ret - values).pow(2).mean()
            loss = pg_loss + cfg.vf_coef * v_loss - cfg.ent_coef * entropy

            optimizer.zero_grad(set_to_none=True)
            loss.backward()
            nn.utils.clip_grad_norm_(policy.parameters(), cfg.max_grad_norm)
            optimizer.step()

    with torch.no_grad():
        approx_kl = (old_logp - new_logp).mean().item()
        clipfrac = (torch.gt(torch.abs(ratio - 1.0), cfg.clip_coef)).float().mean().item()
    return {
        "loss": float(loss.item()),
        "pg_loss": float(pg_loss.mean().item()),
        "v_loss": float(v_loss.item()),
        "entropy": float(entropy.item()),
        "approx_kl": approx_kl,
        "clipfrac": clipfrac,
    }


def evaluate(env: SokobanEnv, policy: SmallSokobanCNN, board_shape: Tuple[int, int], device: str, episodes: int = 5):
    policy.eval()
    returns = []
    with torch.no_grad():
        for _ in range(episodes):
            obs_text = env.reset()
            done = False
            ep_ret = 0.0
            steps = 0
            while not done and steps < 200:
                obs_t = parse_grid_text(obs_text, board_shape).unsqueeze(0).to(device)
                logits, _ = policy(obs_t)
                dist = Categorical(logits=logits)
                act_model = torch.argmax(dist.probs, dim=-1)[0].item()
                act_env = act_model + 1
                obs_text, reward, done, info = env.step(act_env)
                ep_ret += reward
                steps += 1
            returns.append(ep_ret)
    return float(np.mean(returns)), float(np.std(returns))


def main():
    parser = argparse.ArgumentParser()
    # Sokoban config flags to preserve exact environment
    parser.add_argument("--dim_x", type=int, default=None)
    parser.add_argument("--dim_y", type=int, default=None)
    parser.add_argument("--max_steps", type=int, default=None)
    parser.add_argument("--num_boxes", type=int, default=None)
    parser.add_argument("--search_depth", type=int, default=None)
    parser.add_argument("--render_mode", type=str, default=None, choices=[None, "text", "rgb_array"])
    parser.add_argument("--observation_format", type=str, default=None, choices=[None, "grid", "coord", "grid_coord"])

    # PPO/training
    parser.add_argument("--total_steps", type=int, default=200_000)
    parser.add_argument("--rollout_steps", type=int, default=256)
    parser.add_argument("--batch_size", type=int, default=256)
    parser.add_argument("--update_epochs", type=int, default=4)
    parser.add_argument("--gamma", type=float, default=0.99)
    parser.add_argument("--gae_lambda", type=float, default=0.95)
    parser.add_argument("--clip_coef", type=float, default=0.2)
    parser.add_argument("--ent_coef", type=float, default=0.01)
    parser.add_argument("--vf_coef", type=float, default=0.5)
    parser.add_argument("--max_grad_norm", type=float, default=0.5)
    parser.add_argument("--lr", type=float, default=2.5e-4)
    parser.add_argument("--device", type=str, default="cpu")
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--eval_interval", type=int, default=5000)
    parser.add_argument("--eval_episodes", type=int, default=5)
    parser.add_argument("--save_path", type=str, default="runs/sokoban_small_ppo.pt")
    parser.add_argument("--sanity_rollout", action="store_true", help="Run a short rollout to validate parsing & action mapping, then exit")

    args = parser.parse_args()

    # Build Sokoban config strictly following defaults unless explicitly overridden
    env_cfg = SokobanEnvConfig()
    if args.dim_x is not None and args.dim_y is not None:
        env_cfg.dim_room = (args.dim_x, args.dim_y)
    if args.max_steps is not None:
        env_cfg.max_steps = args.max_steps
    if args.num_boxes is not None:
        env_cfg.num_boxes = args.num_boxes
    if args.search_depth is not None:
        env_cfg.search_depth = args.search_depth
    if args.render_mode is not None:
        env_cfg.render_mode = args.render_mode
    if args.observation_format is not None:
        env_cfg.observation_format = args.observation_format

    # Enforce text + grid parsing, which matches LLM environment training by default
    assert env_cfg.render_mode == "text", "Training expects text observations"
    assert env_cfg.observation_format == "grid", "Training expects 'grid' observation format"

    device = torch.device(args.device)

    with all_seed(args.seed):
        env = SokobanEnv(env_cfg)
        # derive board shape from config
        board_shape = env_cfg.dim_room
        obs_text = env.reset()

    policy = SmallSokobanCNN(in_channels=len(SYMBOLS), num_actions=4).to(device)
    optimizer = optim.Adam(policy.parameters(), lr=args.lr)

    if args.sanity_rollout:
        print("[Sanity] Running 10 steps...")
        obs = obs_text
        for t in range(10):
            obs_t = parse_grid_text(obs, board_shape).unsqueeze(0).to(device)
            with torch.no_grad():
                logits, _ = policy(obs_t)
                dist = Categorical(logits=logits)
                a = dist.sample()[0].item()
            obs, r, d, info = env.step(a + 1)
            print(f"t={t} r={r} done={d} info={info}")
            if d:
                obs = env.reset()
        return

    cfg = PPOConfig(
        total_steps=args.total_steps,
        rollout_steps=args.rollout_steps,
        batch_size=args.batch_size,
        update_epochs=args.update_epochs,
        gamma=args.gamma,
        gae_lambda=args.gae_lambda,
        clip_coef=args.clip_coef,
        ent_coef=args.ent_coef,
        vf_coef=args.vf_coef,
        max_grad_norm=args.max_grad_norm,
        lr=args.lr,
        device=args.device,
    )

    steps_done = 0
    last_eval = 0
    start_time = time.time()

    while steps_done < cfg.total_steps:
        data = collect_rollout(env, policy, cfg, board_shape, device)
        steps_done += cfg.rollout_steps

        stats = ppo_update(policy, optimizer, data, cfg)

        if steps_done - last_eval >= args.eval_interval:
            with all_seed(args.seed + 123):
                eval_env = SokobanEnv(env_cfg)
                mean_ret, std_ret = evaluate(eval_env, policy, board_shape, device, episodes=args.eval_episodes)
            last_eval = steps_done
            elapsed = time.time() - start_time
            print(
                f"steps={steps_done} elapsed={elapsed:.1f}s loss={stats['loss']:.3f} "
                f"pg={stats['pg_loss']:.3f} v={stats['v_loss']:.3f} ent={stats['entropy']:.3f} "
                f"kl={stats['approx_kl']:.4f} clipfrac={stats['clipfrac']:.3f} eval_ret={mean_ret:.2f}±{std_ret:.2f}"
            )
            # Save
            os.makedirs(os.path.dirname(args.save_path), exist_ok=True)
            torch.save({
                "model_state": policy.state_dict(),
                "env_cfg": env_cfg.__dict__,
                "steps": steps_done,
                "seed": args.seed,
            }, args.save_path)

    print(f"Training finished. Model saved to {args.save_path}")


if __name__ == "__main__":
    main()