import json
import time
import numpy as np
from anytime_pd import solve_full, hierarchy, stop_level


def one(seed, n=24):
    rng = np.random.default_rng(seed)
    # Bounded feasible LP with a dense coupling block.
    A = np.vstack([np.eye(n), -np.eye(n), rng.normal(size=(n // 2, n))])
    b = np.concatenate([np.ones(n), np.ones(n), 1.5 * np.ones(n // 2)])
    c = rng.uniform(0.05, 1.0, n)
    t0 = time.perf_counter()
    lp, ld, _, ystar = solve_full(A, b, c)
    full_time = time.perf_counter() - t0
    bases = [np.eye(n)[:, :k] for k in range(2, n + 1, 2)]
    # This is deliberately marked oracle-seeded: it supplies a known feasible
    # dual point, allowing us to test certificate mechanics independently of
    # the difficult problem of finding the first dual feasible point.
    dual_bases = [np.column_stack([ystar, np.eye(len(b))[:, :k]])
                  for k in range(2, n + 1, 2)]
    t1 = time.perf_counter()
    rows = hierarchy(A, b, c, bases, dual_bases, full_opt=lp)
    anytime_time = time.perf_counter() - t1
    level = stop_level(rows, tau=0.02)
    return {
        "seed": seed, "full_time_sec": full_time,
        "anytime_all_levels_sec": anytime_time,
        "target_level": level, "n_levels": len(rows),
        "full_opt": lp, "final_lower": rows[-1].lower,
        "coverage": all(x.covers_full for x in rows),
        "monotone_width": all(x.width >= y.width - 1e-8
                               for x, y in zip(rows, rows[1:])),
        "widths": [x.width for x in rows],
    }


def main():
    rows = [one(s) for s in range(5)]
    print(json.dumps({"trials": rows,
                      "median_full_sec": float(np.median([x["full_time_sec"] for x in rows])),
                      "median_anytime_sec": float(np.median([x["anytime_all_levels_sec"] for x in rows])),
                      "all_coverage": all(x["coverage"] for x in rows),
                      "all_monotone": all(x["monotone_width"] for x in rows)}, indent=2))


if __name__ == "__main__":
    main()