"""
Zeno Interval — Vary the inter-measurement gap.

N=32 fixed. Insert deliberate delays of 0, 5, 10, 20, 50, 100μs between
each measurement. At 100μs the gap approaches T1 — Zeno protection
should collapse. Maps the phase boundary between Zeno-protected and
unprotected thermalization.

Theory predicts: fidelity depends on the ratio of measurement rate to
decoherence rate. When inter-measurement interval << T1, Zeno wins.
When interval ≈ T1, the qubit thermalizes between measurements and
Zeno can't help.
"""

import json
import sys
from datetime import datetime, timezone
from dataclasses import dataclass
from pathlib import Path
import numpy as np
from scipy.special import comb

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import (
    QiskitRuntimeService,
    SamplerV2,
    Batch,
)


DATA_DIR = Path("D:/qiskit-zenodragging")
N_MEAS = 32


@dataclass
class ExperimentConfig:
    name: str
    circuit: QuantumCircuit
    category: str
    params: dict


def log(msg, level=0):
    indent = "  " * level
    ts = datetime.now().strftime("%H:%M:%S")
    print(f"[{ts}] {indent}{msg}")


def check_usage(service):
    jobs = list(service.jobs(limit=200))
    now = datetime.now(timezone.utc)
    month_start = datetime(now.year, now.month, 1, tzinfo=timezone.utc)
    total = 0
    for j in jobs:
        u = j.usage() or 0
        try:
            m = j.metrics()
            ts = m.get('timestamps', {}).get('created', '')
            if ts:
                dt = datetime.fromisoformat(ts.replace('Z', '+00:00'))
                if dt >= month_start:
                    total += u
        except Exception:
            pass
    return {"total": total, "remaining": 600 - total, "percentage": 100 * total / 600}


def build_zeno_with_gap(theta, n_meas, gap_dt):
    """Zeno drag with deliberate delay between each measurement."""
    qr = QuantumRegister(1, 'q')
    cr = ClassicalRegister(n_meas + 1, 'c')
    qc = QuantumCircuit(qr, cr)

    for k in range(1, n_meas + 1):
        theta_k = k * theta / n_meas
        qc.ry(-theta_k, 0)
        qc.measure(0, k - 1)
        qc.ry(theta_k, 0)
        if gap_dt > 0 and k < n_meas:
            qc.delay(gap_dt, 0, unit='dt')

    qc.ry(-theta, 0)
    qc.measure(0, n_meas)
    return qc


def build_identity_zeno_with_gap(n_meas, gap_dt):
    """Identity Zeno with deliberate delay between each measurement."""
    qr = QuantumRegister(1, 'q')
    cr = ClassicalRegister(n_meas + 1, 'c')
    qc = QuantumCircuit(qr, cr)

    for k in range(n_meas):
        qc.measure(0, k)
        if gap_dt > 0 and k < n_meas - 1:
            qc.delay(gap_dt, 0, unit='dt')

    qc.measure(0, n_meas)
    return qc


def build_delay_total(total_delay_dt):
    """Pure delay for same total circuit time. Ideal = |0>."""
    qc = QuantumCircuit(1, 1)
    if total_delay_dt > 0:
        qc.delay(total_delay_dt, 0, unit='dt')
    qc.measure(0, 0)
    return qc


def analyze_zeno(bitstrings, n_meas, p_meas):
    total = len(bitstrings)
    successful = 0
    correct_given_success = 0
    flip_bins = {}

    for bs in bitstrings:
        if len(bs) < n_meas + 1:
            continue

        final = bs[0]
        intermediate = bs[1:n_meas + 1]
        n_flips = sum(1 for b in intermediate if b == '1')

        if n_flips not in flip_bins:
            flip_bins[n_flips] = {'total': 0, 'correct': 0}
        flip_bins[n_flips]['total'] += 1
        if final == '0':
            flip_bins[n_flips]['correct'] += 1

        if n_flips == 0:
            successful += 1
            if final == '0':
                correct_given_success += 1

    success_rate = successful / total if total > 0 else 0
    fidelity_hard = correct_given_success / successful if successful > 0 else 0

    expected_meas_flips = n_meas * p_meas

    # Excess-flip weighting
    w_c, w_t = 0, 0
    for nf, data in flip_bins.items():
        excess = max(0, nf - expected_meas_flips)
        w = np.exp(-excess)
        w_c += w * data['correct']
        w_t += w * data['total']
    fid_excess = w_c / w_t if w_t > 0 else 0

    # Likelihood ratio
    wl_c, wl_t = 0, 0
    for nf, data in flip_bins.items():
        if nf <= n_meas:
            p_target = comb(n_meas, nf, exact=True) * (p_meas ** nf) * ((1 - p_meas) ** (n_meas - nf))
            p_random = comb(n_meas, nf, exact=True) * (0.5 ** n_meas)
            w = min(p_target / p_random, 1e10) if p_random > 0 else 0
        else:
            w = 0
        wl_c += w * data['correct']
        wl_t += w * data['total']
    fid_likelihood = wl_c / wl_t if wl_t > 0 else 0

    all_flips = []
    for nf, data in flip_bins.items():
        all_flips.extend([nf] * data['total'])
    mean_flips = np.mean(all_flips) if all_flips else 0
    std_flips = np.std(all_flips) if all_flips else 0

    return {
        'total': total,
        'successful': successful,
        'success_rate': success_rate,
        'fidelity_hard_ps': fidelity_hard,
        'fidelity_excess': fid_excess,
        'fidelity_likelihood': fid_likelihood,
        'expected_meas_flips': expected_meas_flips,
        'mean_flips': mean_flips,
        'std_flips': std_flips,
        'flip_distribution': {str(k): v for k, v in sorted(flip_bins.items())},
        'type': 'zeno',
    }


def analyze_standard(bitstrings):
    total = len(bitstrings)
    zeros = sum(1 for b in bitstrings if b[-1] == '0')
    return {'total': total, 'fidelity': zeros / total, 'type': 'standard'}


def main():
    print("=" * 70)
    print("ZENO INTERVAL — VARY INTER-MEASUREMENT GAP")
    print("=" * 70)

    service = QiskitRuntimeService(channel="ibm_cloud", instance="claude")

    usage_before = check_usage(service)
    log(f"Usage: {usage_before['total']}s / 600s ({usage_before['percentage']:.1f}%)")
    log(f"Remaining: {usage_before['remaining']}s")

    if usage_before['remaining'] < 30:
        log("Less than 30s remaining. Aborting.")
        return

    backend = service.backend("ibm_torino")
    log(f"Backend: {backend.name} ({backend.num_qubits}q)")

    dt = backend.dt
    target_obj = backend.target
    meas_props = target_obj['measure'][(0,)]
    meas_duration_s = meas_props.duration
    meas_duration_dt = int(meas_duration_s / dt)
    meas_error = meas_props.error

    props = backend.qubit_properties(0)
    T1 = props.t1
    T2 = props.t2

    log(f"Measurement: {meas_duration_s*1e6:.3f} us ({meas_duration_dt} dt), error={meas_error:.4f}")
    log(f"Qubit 0: T1={T1*1e6:.1f} us, T2={T2*1e6:.1f} us")
    log(f"dt = {dt*1e9:.1f} ns")

    # Gap values in microseconds
    gap_us_values = [0, 5, 10, 20, 50, 100]
    theta = np.pi
    shots = 4096

    print(f"\nN = {N_MEAS} fixed")
    print(f"\nExperiment plan:")
    print(f"{'Gap(us)':>7} | {'Interval(us)':>12} | {'Interval/T1':>11} | {'Total(us)':>9} | {'Total/T1':>8}")
    print("-" * 55)
    for gap_us in gap_us_values:
        interval = meas_duration_s * 1e6 + gap_us
        total = N_MEAS * interval
        print(f"{gap_us:7.0f} | {interval:12.1f} | {interval / (T1*1e6):11.3f} | {total:9.1f} | {total / (T1*1e6):8.2f}")

    all_experiments = []

    for gap_us in gap_us_values:
        gap_s = gap_us * 1e-6
        gap_dt = int(gap_s / dt)
        interval_us = meas_duration_s * 1e6 + gap_us
        total_time_us = N_MEAS * interval_us

        # X Zeno with gap
        all_experiments.append(ExperimentConfig(
            name=f"x_zeno_gap{gap_us}",
            circuit=build_zeno_with_gap(theta, N_MEAS, gap_dt),
            category="x_zeno",
            params={'gate': 'X', 'theta': theta, 'n_meas': N_MEAS,
                    'gap_us': gap_us, 'gap_dt': gap_dt,
                    'interval_us': interval_us,
                    'interval_over_T1': interval_us / (T1 * 1e6),
                    'total_time_us': total_time_us,
                    'T1_multiple': total_time_us / (T1 * 1e6)},
        ))

        # Identity Zeno with gap
        all_experiments.append(ExperimentConfig(
            name=f"identity_zeno_gap{gap_us}",
            circuit=build_identity_zeno_with_gap(N_MEAS, gap_dt),
            category="identity_zeno",
            params={'gate': 'I', 'theta': 0, 'n_meas': N_MEAS,
                    'gap_us': gap_us, 'gap_dt': gap_dt,
                    'interval_us': interval_us,
                    'interval_over_T1': interval_us / (T1 * 1e6),
                    'total_time_us': total_time_us,
                    'T1_multiple': total_time_us / (T1 * 1e6)},
        ))

        # Delay-matched (same total time, no measurements)
        total_delay_dt = int(total_time_us * 1e-6 / dt)
        all_experiments.append(ExperimentConfig(
            name=f"delay_gap{gap_us}",
            circuit=build_delay_total(total_delay_dt),
            category="delay",
            params={'gate': 'I', 'theta': 0, 'n_meas': 0,
                    'gap_us': gap_us,
                    'total_time_us': total_time_us,
                    'T1_multiple': total_time_us / (T1 * 1e6)},
        ))

    log(f"Total experiments: {len(all_experiments)}")

    log("Transpiling...")
    pm = generate_preset_pass_manager(backend=backend, optimization_level=1)

    transpiled = []
    for exp in all_experiments:
        try:
            tc = pm.run(exp.circuit)
            transpiled.append(tc)
        except Exception as e:
            log(f"ERROR transpiling {exp.name}: {e}")
            transpiled.append(None)

    valid_indices = [i for i, tc in enumerate(transpiled) if tc is not None]
    valid_transpiled = [transpiled[i] for i in valid_indices]
    valid_experiments = [all_experiments[i] for i in valid_indices]

    log(f"Transpiled: {len(valid_transpiled)}/{len(all_experiments)}")

    depths = [tc.depth() for tc in valid_transpiled]
    log(f"Depths: min={min(depths)}, max={max(depths)}")

    for i, exp in enumerate(valid_experiments):
        exp.params['transpiled_depth'] = depths[i]

    log("Submitting batch...")
    start_time = datetime.now(timezone.utc)

    with Batch(backend=backend) as batch:
        sampler = SamplerV2(mode=batch)
        job = sampler.run(valid_transpiled, shots=shots)
        log(f"Job ID: {job.job_id()}")
        log("Waiting...")
        job.wait_for_final_state()

    end_time = datetime.now(timezone.utc)
    wall_time = (end_time - start_time).total_seconds()
    log(f"Done. Wall time: {wall_time:.1f}s, QPU: {job.usage() or 0}s")

    result = job.result()
    metrics = job.metrics()
    results_data = {}

    for i, exp in enumerate(valid_experiments):
        pub_result = result[i]
        data_bin = pub_result.data

        if hasattr(data_bin, 'c'):
            bitstrings = list(data_bin.c.get_bitstrings())
        elif hasattr(data_bin, 'meas'):
            bitstrings = list(data_bin.meas.get_bitstrings())
        else:
            cr_name = list(data_bin.keys())[0]
            bitstrings = list(getattr(data_bin, cr_name).get_bitstrings())

        if 'zeno' in exp.category:
            analysis = analyze_zeno(bitstrings, exp.params['n_meas'], meas_error)
        else:
            analysis = analyze_standard(bitstrings)

        results_data[exp.name] = {
            'category': exp.category,
            'params': {k: (float(v) if isinstance(v, (np.floating, float)) else v)
                       for k, v in exp.params.items()},
            'analysis': analysis,
            'raw_bitstrings': bitstrings[:500],
        }

    # Save
    output = {
        'experiment': 'zeno_interval',
        'description': 'Vary inter-measurement gap to map the Zeno protection phase boundary',
        'timestamp': start_time.isoformat(),
        'backend': backend.name,
        'shots': shots,
        'n_meas': N_MEAS,
        'job_id': job.job_id(),
        'usage_seconds': job.usage() or 0,
        'wall_time_seconds': wall_time,
        'metrics': metrics,
        'hardware_timing': {
            'dt_ns': dt * 1e9,
            'measurement_duration_us': meas_duration_s * 1e6,
            'measurement_duration_dt': meas_duration_dt,
            'measurement_error': meas_error,
            'qubit_0_T1_us': T1 * 1e6,
            'qubit_0_T2_us': T2 * 1e6,
        },
        'results': results_data,
    }

    outfile = DATA_DIR / 'results' / 'zeno_interval' / 'zeno_interval.json'
    outfile.parent.mkdir(exist_ok=True)
    with open(outfile, 'w') as f:
        json.dump(output, f, indent=2, default=str)
    log(f"Saved: {outfile}")

    # =========================================================================
    # THE PHASE BOUNDARY
    # =========================================================================
    print("\n" + "=" * 70)
    print("ZENO PHASE BOUNDARY — INTER-MEASUREMENT INTERVAL")
    print("=" * 70)

    print(f"\nN = {N_MEAS}, Qubit 0 T1 = {T1*1e6:.1f} us")

    print(f"\n{'Gap(us)':>7} | {'Interval':>8} | {'Int/T1':>6} | {'X Zeno':>7} | {'I Zeno':>7} | "
          f"{'Delay':>7} | {'X-Delay':>7} | {'Total':>7} | {'×T1':>5}")
    print("-" * 85)

    for gap_us in gap_us_values:
        xk = f"x_zeno_gap{gap_us}"
        ik = f"identity_zeno_gap{gap_us}"
        dk = f"delay_gap{gap_us}"

        if not all(k in results_data for k in [xk, ik, dk]):
            continue

        xa = results_data[xk]['analysis']
        ia = results_data[ik]['analysis']
        da = results_data[dk]['analysis']
        xp = results_data[xk]['params']

        gap_xd = xa['fidelity_excess'] - da['fidelity']

        print(f"{gap_us:7.0f} | {xp['interval_us']:6.1f}us | {xp['interval_over_T1']:6.3f} | "
              f"{xa['fidelity_excess']:7.4f} | {ia['fidelity_excess']:7.4f} | "
              f"{da['fidelity']:7.4f} | {gap_xd:+7.4f} | {xp['total_time_us']:5.0f}us | {xp['T1_multiple']:4.1f}x")

    # Find crossover
    print(f"\n{'=' * 70}")
    print("ANALYSIS")
    print(f"{'=' * 70}")

    prev_gap = None
    prev_advantage = None
    for gap_us in gap_us_values:
        xk = f"x_zeno_gap{gap_us}"
        dk = f"delay_gap{gap_us}"
        if xk in results_data and dk in results_data:
            adv = results_data[xk]['analysis']['fidelity_excess'] - results_data[dk]['analysis']['fidelity']
            if prev_advantage is not None and adv <= 0 and prev_advantage > 0:
                print(f"\n  Zeno advantage crosses zero between gap={prev_gap}us and gap={gap_us}us")
            prev_gap = gap_us
            prev_advantage = adv

    # Compare 0 gap vs 100 gap
    x0 = results_data.get('x_zeno_gap0', {}).get('analysis', {}).get('fidelity_excess', 0)
    x100 = results_data.get('x_zeno_gap100', {}).get('analysis', {}).get('fidelity_excess', 0)
    i0 = results_data.get('identity_zeno_gap0', {}).get('analysis', {}).get('fidelity_excess', 0)
    i100 = results_data.get('identity_zeno_gap100', {}).get('analysis', {}).get('fidelity_excess', 0)

    print(f"\n  X Zeno:  gap=0 → {x0:.4f},  gap=100μs → {x100:.4f},  decline: {x0-x100:.4f}")
    print(f"  I Zeno:  gap=0 → {i0:.4f},  gap=100μs → {i100:.4f},  decline: {i0-i100:.4f}")

    usage_after = check_usage(service)
    log(f"\nUsage: {usage_after['total']}s / 600s ({usage_after['percentage']:.1f}%)")
    log(f"This job: {job.usage() or 0}s")


if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        log("Interrupted.")
        sys.exit(1)
    except Exception as e:
        log(f"FATAL: {e}")
        import traceback
        traceback.print_exc()
        sys.exit(1)