"""Tournament-based relative-ranking optimization of the mind supernet (Sec 4.4).

For each query, sample K flows from the controller, execute them, rank the K ideas
with the anchor-based tournament, convert ranks -> quantile rewards (Eq 11) ->
standardized advantages (Eq 12), and update the controller by REINFORCE (Eq 13).
"""
from __future__ import annotations
import numpy as np
import torch
from .flow import execute_flow
from .tournament import tournament_rank, pointwise_scores
from . import llm


def make_context(topic, related, limit=5):
    rw = "\n".join(f"- {r}" for r in (related or [])[:limit]) or "(none)"
    return f"Topic: {topic}\nRelated works:\n{rw}"


def _execute_group(flows, topic, related, gen_model, base_seed, workers=6):
    def run(k):
        seq = flows[k][0]
        idea, _ = execute_flow(seq, topic, related, model=gen_model, seed=base_seed + k * 97)
        return idea
    return llm.parallel_map(run, list(range(len(flows))), workers=workers)


def train_step(net, opt, query, K, gen_model, judge_model, rng, lam=0.02, seed=0,
               reward_mode="tournament", workers=6):
    topic, related = query["topic"], query["related"]
    ctx = make_context(topic, related)
    flows = [net.sample_flow(topic, rng) for _ in range(K)]
    ideas = _execute_group(flows, topic, related, gen_model, seed, workers=workers)
    costs = np.array([net.flow_cost(seq) for seq, _ in flows], dtype=float)
    cost_norm = costs / max(costs.max(), 1.0)

    if reward_mode == "tournament":
        ranks, scores = tournament_rank(ideas, ctx, model=judge_model, seed=seed)
        r = 1.0 - np.array(ranks, dtype=float) / max(K - 1, 1) - lam * cost_norm
        quality = 1.0 - np.array(ranks, dtype=float) / max(K - 1, 1)  # rank-quality for logging
    else:  # pointwise scalar reward baseline (judgment collapse)
        ps = np.array(pointwise_scores(ideas, ctx, model=judge_model, seed=seed), dtype=float)
        r = ps / 10.0 - lam * cost_norm
        quality = ps / 10.0

    adv = (r - r.mean()) / (r.std() + 1e-6)
    # REINFORCE update
    opt.zero_grad()
    loss = torch.tensor(0.0)
    for k in range(K):
        logp = net.log_prob(topic, flows[k][1])
        loss = loss - float(adv[k]) * logp
    loss = loss / K
    loss.backward()
    torch.nn.utils.clip_grad_norm_(net.parameters(), 5.0)
    opt.step()

    return {
        "loss": float(loss.item()),
        "reward_mean": float(r.mean()),
        "reward_std": float(r.std()),
        "quality_mean": float(quality.mean()),
        "quality_spread": float(quality.max() - quality.min()),
        "flows": [flows[k][0] for k in range(K)],
        "ideas": ideas,
        "ctx": ctx,
    }