"""
PHOENIX quantum feasibility sweep -- master runner.

Runs every screen + the stacking evaluation, scores each against a mandatory
classical baseline by the same metric, and writes an honest record + verdict.
All CPU/simulator, no QPU, load-light.
"""
from __future__ import annotations
import json, os, time, traceback
import numpy as np

from qsweep_core import ScreenResult
import qsweep_screens as S
import qsweep_more as M
from qsweep_stack import evaluate_stacking

SCREENS = [
    ("58/158 QSVM (qiskit ZZ kernel)", S.screen_qsvm_qiskit),
    ("158 quantum kernel (PennyLane)", S.screen_qkernel_pennylane),
    ("63/161 tensor network (TT-SVD)", M.screen_tensor_network),
    ("59 quantum clustering (QUBO/SA)", M.screen_quantum_clustering),
    ("RX quantum one-class anomaly", M.screen_quantum_anomaly),
    ("61/62 QFT deconvolution", M.screen_qft_deconvolution),
    ("57/65 quantum particle filter", M.screen_particle_filter),
    ("64/160 quantum graph fusion (QAOA)", M.screen_graph_fusion),
    ("60 quantum image rep (FRQI)", M.screen_image_rep),
]


def main():
    results = []
    for label, fn in SCREENS:
        t = time.perf_counter()
        try:
            r = fn()
            results.append(r)
            print(f"[done {time.perf_counter()-t:6.1f}s] {r.name:<44} "
                  f"q={r.quantum_metric:+.3f} classical={r.classical_metric:+.3f} "
                  f"({r.metric_name}) -> {'ADVANTAGE' if r.advantage() else 'no advantage'}")
        except Exception as e:
            print(f"[ERROR] {label}: {e}")
            traceback.print_exc()
            results.append(ScreenResult(label, "-", float('nan'), float('nan'), None,
                                        "-", time.perf_counter()-t, verdict=f"ERROR: {e}"))

    print("\n[stacking] running hybrid/stacked evaluation ...")
    try:
        stack = evaluate_stacking()
    except Exception as e:
        traceback.print_exc()
        stack = {"error": str(e)}

    # ---- report ----
    print("\n" + "=" * 82)
    print("PHOENIX QUANTUM FEASIBILITY SWEEP -- results (quantum vs mandatory classical)")
    print("=" * 82)
    print(f"{'method (list item)':<44} {'quantum':>9} {'classical':>9} {'metric':>9}  verdict")
    print("-" * 82)
    n_adv = 0
    for r in results:
        adv = r.advantage() if not np.isnan(r.quantum_metric) else False
        n_adv += int(adv)
        print(f"{r.name:<44} {r.quantum_metric:>9.3f} {r.classical_metric:>9.3f} "
              f"{r.metric_name:>9}  {'ADVANTAGE' if adv else 'no advantage'}")
    print("-" * 82)
    print(f"screens with any quantum advantage over classical: {n_adv} / {len(results)}")
    if isinstance(stack, dict) and "emergent_lift" in stack:
        print(f"stacking: best_single={stack['best_single']}  best_stack={stack['best_stack']}  "
              f"emergent_lift={stack['emergent_lift']:+.3f}")
        print(f"  -> {stack['verdict']}")

    record = {
        "task": "PHOENIX fire-detection feasibility (SEVIRI-calibrated, sim-first)",
        "discipline": "each quantum method vs mandatory classical baseline, same metric; "
                      "placebo where learned; nothing promoted; escalate survivors to real corpus",
        "screens": [{
            "method": r.name, "task": r.task, "quantum_metric": round(r.quantum_metric, 4),
            "classical_metric": round(r.classical_metric, 4), "metric": r.metric_name,
            "advantage": bool(r.advantage()) if not np.isnan(r.quantum_metric) else None,
            "latency_s": round(r.latency_s, 1), "extra": _clean(r.extra), "verdict": r.verdict,
        } for r in results],
        "stacking": stack,
        "screens_with_advantage": n_adv,
        "overall_verdict": (
            "No single quantum/quantum-inspired method beat its classical baseline on real-shaped "
            "PHOENIX detection tasks, and stacking produced no emergent value beyond the classical "
            "incumbent. Consistent with entries 0091/0093: quantum is a benchmark, not a capability, "
            "at PHOENIX scale. The one deployable quantum-adjacent win is post-quantum signed alerts "
            "(pqc_alerting.py), which is orthogonal to detection." if n_adv == 0 else
            f"{n_adv} screen(s) showed a possible lift -- escalate to the real spec12 corpus on RunPod "
            "with a placebo and cross-validation before any claim."),
    }
    os.makedirs("results", exist_ok=True)
    with open("results/quantum_sweep_results.json", "w", encoding="utf-8") as f:
        json.dump(record, f, indent=2)
    print("\nrecord -> results/quantum_sweep_results.json")


def _clean(d):
    return {k: (round(v, 4) if isinstance(v, float) else v) for k, v in (d or {}).items()}


if __name__ == "__main__":
    main()