#!/usr/bin/env python3
"""Helpers that build episode configs from the runner defaults (runner/default_config.json).
Episode files must carry the explicit latency block that these helpers produce (the runner itself keeps "no latency
default" so every episode is self-describing).

    from default_episode import load_default, latency_for, recovery_episode, nominal_episode, draw_placement

* recovery_episode() takes a rigid `placement` {'heading': rad, 'x0': m, 'y0': m} applied to BOTH the straight
  reference and the initial pose (placement is a per-scenario nuisance factor shared by all controllers);
  nominal_episode() takes an optional placement that turns the released CSV into a `csv_transformed` reference
  (randomized full-path runs). With placement=None the configs use the canonical +x frame at the origin.
* recovery_episode() and nominal_episode() take an optional `control_start_s` (default: default_config
  'control_start_s' = 0.0). The horizon is extended by the same amount, so every controller has the horizon H
  measured from control start (the runner measures ST from control start).
* recovery_episode(..., horizon_s=H) overrides the recovery horizon (e.g. 40 s for the main TR table B01, scored
  offline at H = 15/25/40 s); the horizon is still extended by control_start_s. Combine with
  termination={'stop_on_divergence': False} to run every recovery episode to its full horizon.
* controller_spec(d, controller_id) returns (controller, controller_params) for a registered controller id
  (default_config.json 'controller_registry'; e.g. 'nnhd_x1.75').
"""
import json
import math
import os

HERE = os.path.dirname(os.path.abspath(__file__))
DEFAULT_PATH = os.path.join(HERE, 'default_config.json')


def load_default(path=DEFAULT_PATH):
    import hashlib
    with open(path, 'rb') as f:
        raw = f.read()
    d = json.loads(raw)
    d['_sha256'] = hashlib.sha256(raw).hexdigest()
    return d


def compute_delay_for(d, controller, controller_params=None):
    table = d['latency']['compute_delay_s_by_controller']
    if controller in table:
        return table[controller]
    if controller == 'plugin:wrapped_released' and controller_params and controller_params.get('base') in table:
        return table[controller_params['base']]
    return table['plugin_default']


def latency_for(d, controller, controller_params=None, phase_s=0.0, model=None):
    """Explicit latency block for one episode. model=None -> runner default; 'ideal' -> no latency."""
    lat = d['latency']
    if (model or lat['model']) == 'ideal':
        return {'model': 'ideal'}
    P = lat['controller_period_s']
    if not (0.0 <= phase_s < P):
        raise ValueError(f'phase {phase_s} outside [0, {P})')
    return {'model': 'ros_emulated', 'controller_period_s': P, 'controller_phase_s': round(phase_s, 3),
            'compute_delay_s': compute_delay_for(d, controller, controller_params), 'state_delay_s': lat['state_delay_s'],
            'state_rate_hz': lat['state_rate_hz'], 'driver_rate_hz': lat['driver_rate_hz']}


def controller_spec(d, controller_id):
    """(controller, controller_params or None) for a registered controller id (default_config 'controller_registry').
    The params are copied, so callers cannot modify the runner default."""
    reg = d['controller_registry']['ids']
    if controller_id not in reg:
        raise KeyError(f'unknown controller id {controller_id!r}; registered: {sorted(reg)}')
    e = reg[controller_id]
    params = e.get('controller_params')
    return e['controller'], (json.loads(json.dumps(params)) if params else None)


def draw_placement(d, rng):
    """One rigid placement from the nuisance distribution (3 draws, in this order: heading, x0, y0)."""
    p = d['placement']
    h = float(rng.uniform(p['heading_rad'][0], p['heading_rad'][1]))
    x0 = float(rng.uniform(p['origin_box_m'][0], p['origin_box_m'][1]))
    y0 = float(rng.uniform(p['origin_box_m'][0], p['origin_box_m'][1]))
    return {'heading': h, 'x0': x0, 'y0': y0}


def _place(placement, x, y, yaw):
    if not placement:
        return x, y, yaw
    c, s = math.cos(placement['heading']), math.sin(placement['heading'])
    return (placement['x0'] + c * x - s * y, placement['y0'] + s * x + c * y, yaw + placement['heading'])


def _control_start(d, control_start_s):
    c0 = d['control_start_s'] if control_start_s is None else float(control_start_s)
    if c0 < 0 or abs(c0 * 1000 - round(c0 * 1000)) > 1e-9:
        raise ValueError(f'control_start_s {c0} must be a non-negative multiple of 1 ms')
    return round(c0, 3)


def recovery_episode(d, episode_id, scenario_id, controller, e_m, phi_rad, phase_s, controller_params=None,
                     perturbation=None, termination=None, model=None, tags=None, placement=None, control_start_s=None,
                     horizon_s=None):
    """Paper geometry in the path frame: straight reference along the path-frame +x axis; vehicle displaced
    laterally by e (positive = left of the path, path-frame +y) and misaligned by phi (CCW positive), at rest.
    The pose is given in default_config 'recovery.initial_pose_frame'. `placement` rigidly moves reference and pose."""
    r = d['recovery']
    ref = dict(r['reference'])
    if placement:
        ref.update({'x0': placement['x0'], 'y0': placement['y0'], 'heading': placement['heading']})
    x, y, yaw = _place(placement, r['start_x_m'], float(e_m), float(phi_rad))
    c0 = _control_start(d, control_start_s)
    ep = {'episode_id': episode_id, 'scenario_id': scenario_id, 'controller': controller,
          'reference': ref,
          'initial_pose': {'x': x, 'y': y, 'yaw': yaw, 'frame': r['initial_pose_frame']},
          'horizon_s': round((r['horizon_s'] if horizon_s is None else float(horizon_s)) + c0, 3), 'control_start_s': c0,
          'latency': latency_for(d, controller, controller_params, phase_s, model),
          'termination': dict(r['termination'], **(termination or {})),
          'mpc_osqp_adaptive_rho_interval': d['mpc_osqp_adaptive_rho_interval'],
          'tags': dict(tags or {}, default_config_sha256=d.get('_sha256'), e_m=float(e_m), phi_rad=float(phi_rad),
                       placement=placement)}
    if controller_params:
        ep['controller_params'] = controller_params
    if perturbation:
        ep['perturbation'] = perturbation
    return ep


def nominal_episode(d, episode_id, path_key, controller, phase_s=0.0, controller_params=None, initial_pose=None,
                    perturbation=None, model=None, tags=None, placement=None, scenario_id=None, control_start_s=None):
    n = d['nominal']
    p = n['paths'][path_key]
    pose = dict(initial_pose or n['initial_pose'])
    if placement:
        ref = {'type': 'csv_transformed', 'name': p['reference'], 'dx': placement['x0'], 'dy': placement['y0'],
               'rotate': placement['heading']}
        pose['x'], pose['y'], pose['yaw'] = _place(placement, pose['x'], pose['y'], pose['yaw'])
    else:
        ref = {'type': 'released_csv', 'name': p['reference']}
    c0 = _control_start(d, control_start_s)
    ep = {'episode_id': episode_id, 'scenario_id': scenario_id or f'nominal_{path_key}', 'controller': controller,
          'reference': ref,
          'initial_pose': pose, 'horizon_s': round(p['horizon_s'] + c0, 3),
          'control_start_s': c0,
          'latency': latency_for(d, controller, controller_params, phase_s, model),
          'termination': dict(n['termination']),
          'mpc_osqp_adaptive_rho_interval': d['mpc_osqp_adaptive_rho_interval'],
          'tags': dict(tags or {}, default_config_sha256=d.get('_sha256'), placement=placement)}
    if controller_params:
        ep['controller_params'] = controller_params
    if perturbation:
        ep['perturbation'] = perturbation
    return ep