"""Convergence harness: ONE fixed instance per seed, shared fitness target."""
import numpy as np, sim, schedulers as sch

def build_instance(n_nodes, lam, seed):
    rng = np.random.default_rng(seed)
    nodes = sim.make_nodes(n_nodes, rng)
    cap, mem, p_idle, p_peak = sim.node_arrays(nodes)
    link_lat = sim.make_link_latency(n_nodes, rng)
    n_arr = rng.poisson(lam * sim.DT * 3)
    demand, tmem, deadline, cls = sim.make_tasks(max(n_arr, 8), rng)
    backlog = rng.uniform(0, cap * sim.DT * 0.5)
    return dict(demand=demand, tmem=tmem, deadline=deadline, cls=cls,
                backlog=backlog, cap=cap, mem=mem, link_lat=link_lat,
                p_idle=p_idle, p_peak=p_peak)

def _ctx(inst, seed):
    return sch.Ctx(inst["demand"], inst["tmem"], inst["deadline"], inst["cls"],
                   inst["backlog"], inst["cap"], inst["link_lat"],
                   inst["p_idle"], inst["p_peak"], 0.5, 0.3, 0.2,
                   np.random.default_rng(seed + 1000), node_mem=inst["mem"])

METHODS = {
    "ACO": lambda c,it: sch.standalone_aco(c, iters=it),
    "PSO": lambda c,it: sch.standalone_pso(c, iters=it),
    "WOA": lambda c,it: sch.woa(c, iters=it),
    "AdaptiSwarm": lambda c,it: sch.adaptiswarm_edge(c, iters=it, sigma_u=0.2),
    "Abl_ACOonly": lambda c,it: sch.adaptiswarm_edge(c, iters=it, use_pso=False, sigma_u=0.2),
    "Abl_PSOrand": lambda c,it: sch.adaptiswarm_edge(c, iters=it, use_aco_seed=False, use_adaptive=False, sigma_u=0.2),
    "Abl_PSOseed": lambda c,it: sch.adaptiswarm_edge(c, iters=it, use_adaptive=False, sigma_u=0.2),
}

def run_curves(n_nodes=25, lam=100, seed=7, iters=40, methods=None):
    if methods is None: methods = ["ACO","PSO","WOA","AdaptiSwarm"]
    inst = build_instance(n_nodes, lam, seed)
    curves = {}
    for m in methods:
        _, c = METHODS[m](_ctx(inst, seed), iters)
        c = list(c)
        if len(c) < iters: c = c + [c[-1]] * (iters - len(c))
        curves[m] = np.array(c[:iters], dtype=float)
    best_final = min(c[-1] for c in curves.values())
    worst_start = max(c[0] for c in curves.values())
    span = abs(worst_start - best_final) + 1e-9
    target = best_final + 0.02 * span
    conv = {}
    for k, c in curves.items():
        hit = np.where(c <= target)[0]
        conv[k] = int(hit[0] + 1) if hit.size else iters
    return curves, conv, target