"""Frozen-policy browser inference."""
import argparse, json, random, time, math, urllib.request
from pathlib import Path
from common import ROOT, PORT, atomic, atomic_jsonl, context, correctness, digest, legal_actions, checkpoint_identity, effective_cost
from gui_env import GUIEnv, rule_action

def rank(obs, adapter=None):
    visible = {k: obs[k] for k in ['instruction', 'elements', 'remaining_actions']}
    payload = json.dumps({'observation': visible, 'adapter': str(adapter) if adapter else None}).encode()
    req = urllib.request.Request(f'http://127.0.0.1:{PORT}/rank', data=payload, headers={'Content-Type': 'application/json'})
    with urllib.request.urlopen(req, timeout=180) as response:
        result = json.load(response)
    if not result.get('actions') or {'kind': 'submit'} not in result['actions']:
        raise RuntimeError('Invalid terminal-inclusive candidate pool')
    return result

def sigmoid(x):
    return 1 / (1 + math.exp(-max(-60.0, min(60.0, x))))

def select(proposal, forecasts, controller):
    alpha = controller.get('alpha', 0.0)
    policy = [math.log(max(proposal['probabilities'][i], 1e-12)) for i in proposal['candidate_ids']]
    if alpha == 0:
        return (0, {'scores': policy, 'alpha': 0.0, 'world_used': False})
    calibration = controller.get('terminal', {'temperature': 1.0, 'bias': 0.0})
    values = []
    for (action, prediction) in zip(proposal['actions'], forecasts):
        if action['kind'] == 'submit':
            v = 2 * sigmoid(prediction['submit_success_logit'] / calibration['temperature'] + calibration['bias']) - 1
        else:
            v = prediction['value']
        values.append(v)
    if alpha == 'pure':
        scores = values
    else:
        mean = sum(values) / len(values)
        std = (sum(((v - mean) ** 2 for v in values)) / len(values)) ** 0.5
        scores = [p + alpha * (v - mean) / max(std, 0.1) for (p, v) in zip(policy, values)]
    return (max(range(len(scores)), key=lambda i: scores[i]), {'scores': scores, 'values': values, 'policy_scores': policy, 'alpha': alpha, 'terminal': calibration, 'world_used': True})

def episode(env, seed, method='policy', model=None, adapter=None, controller=None):
    wall_started = time.time()
    obs = env.reset(seed)
    initial = {k: obs[k] for k in ['instruction', 'elements']}
    started = time.monotonic()
    trace = []
    actions = []
    policy_seconds = world_seconds = browser_seconds = 0.0
    hits = 0
    controller = controller or {'alpha': 'pure'}
    for step in range(8):
        if obs['done']:
            break
        proposal = forecasts = selection = None
        if method == 'rule':
            action = rule_action(obs)
        else:
            proposal = rank(obs, adapter)
            policy_seconds += proposal['seconds']
            hits += int(proposal['cached'])
            enabled = method in ['world', 'hybrid'] and controller['alpha'] != 0
            if enabled:
                if model is None:
                    raise RuntimeError('World selection without a model')
                (forecasts, elapsed) = model.forecast([context(obs, a) for a in proposal['actions']])
                world_seconds += elapsed
            (index, selection) = select(proposal, forecasts, controller if method != 'policy' else {'alpha': 0.0})
            action = proposal['actions'][index]
        (after, elapsed) = env.step(action)
        browser_seconds += elapsed
        row = dict(step=step, before=obs, action=action, after=after, seconds=elapsed)
        row.update(proposal=proposal, forecast=forecasts, selection=selection)
        trace.append(row)
        actions.append(action)
        obs = after
    success = int(bool(obs['submitted'] and obs['done'] and (correctness(obs) == 1.0) and (not obs.get('budget_exhausted'))))
    for row in trace:
        row['episode_success'] = success
    clicks = [a['slot'] for a in actions if a['kind'] == 'click']
    result = {'episode_id': f'{seed}:t0', 'seed': seed, 'initial_hash': digest(initial), 'success': success, 'steps': len(actions), 'actions': actions, 'final': obs, 'wrong_submit': int(obs['submitted'] and (not success)), 'repeated_clicks': len(clicks) - len(set(clicks)), 'partial_fraction': correctness(obs), 'seconds': time.monotonic() - started, 'policy_nominal_seconds': policy_seconds, 'world_seconds': world_seconds, 'browser_seconds': browser_seconds, 'cached_policy_requests': hits, 'method': method, 'adapter': str(adapter) if adapter else None, 'controller': controller if method != 'policy' else {'alpha': 0.0}, 'started': wall_started, 'completed': time.time()}
    return (result, trace)

def rollout(seeds, path, method='policy', model=None, adapter=None, controller=None):
    path = Path(path)
    commits = path.with_suffix('.episodes')
    commits.mkdir(parents=True, exist_ok=True)
    identity = {'seeds': list(seeds), 'method': method, 'world': checkpoint_identity(getattr(model, 'checkpoint_path', None)) if model else None, 'policy': checkpoint_identity(adapter), 'controller': controller, 'protocol': digest(json.loads((ROOT / 'protocol.json').read_text()))}
    meta = path.with_suffix('.identity.json')
    if meta.exists() and json.loads(meta.read_text()) != identity:
        raise RuntimeError('Rollout identity changed: ' + str(path))
    atomic(meta, identity)
    env = GUIEnv()
    records = []
    try:
        for seed in seeds:
            commit = commits / f'{seed}.json'
            if commit.exists():
                record = json.loads(commit.read_text())
                if record['identity_hash'] != digest(identity) or record['result']['seed'] != seed:
                    raise RuntimeError('Invalid committed episode')
            else:
                (result, trace) = episode(env, seed, method, model, adapter, controller)
                record = {'identity_hash': digest(identity), 'result': result, 'transitions': trace}
                atomic(commit, record)
            records.append(record)
            atomic(path.with_suffix('.progress.json'), {'pid': __import__('os').getpid(), 'completed': len(records), 'total': len(seeds), 'updated': time.time()})
            if len(records) % 10 == 0:
                print(json.dumps({'rollout': path.name, 'completed': len(records), 'total': len(seeds)}), flush=True)
    finally:
        env.close()
    outcomes = [r['result'] for r in records]
    trace = [t for r in records for t in r['transitions']]
    atomic_jsonl(path, outcomes)
    atomic_jsonl(path.with_suffix('.transitions.jsonl'), trace)
    atomic(path.with_suffix('.complete.json'), {'identity': identity, 'episodes': len(outcomes), 'transitions': len(trace), 'transactional': True, 'completed': time.time()})
    return outcomes

def summary(rows):
    n = len(rows)
    return {'n': n, 'success_rate': sum((r['success'] for r in rows)) / n, 'mean_steps': sum((r['steps'] for r in rows)) / n, 'mean_seconds': sum((r['seconds'] for r in rows)) / n, 'effective_seconds': effective_cost(rows), 'wrong_submits': sum((r['wrong_submit'] for r in rows)), 'repeated_clicks': sum((r['repeated_clicks'] for r in rows))}