"""
Quantum Metamorphic Testing Dataset 생성 스크립트

TC1~TC6 × {Depolarizing, Amplitude Damping, Phase Damping} × {Z, X 기저} × 노이즈 강도
조합을 Qiskit Aer로 시뮬레이션하고, 측정 빈도와 평가 지표를 CSV로 저장합니다.

사용법:
    pip install qiskit qiskit-aer numpy scipy pandas
    python generate_dataset.py                      # 기본: seed 1234, shots 4096
    python generate_dataset.py --seeds 1234 1 2 3 4 # 반복 실험(시드별 변동성 분석용)
    python generate_dataset.py --max-noise 0.2 --step 0.005 --out data

출력:
    <out>/results.csv        : 실험 1회(조건 1개)당 1행
    <out>/test_cases.csv     : 테스트 케이스 정의와 이상적 출력 분포
    <out>/metadata.json      : 실험 설정 및 라이브러리 버전

Reference:
  W.-Y. Hyun, D. Kang, "Generating Metamorphic Test Cases using 2-qubit Quantum
  Gate Combinations," JKSCI, 31(5), 1-9, 2026. doi:10.9708/jksci.2026.31.05.001
"""

import argparse
import json
import os
import platform
import time

import numpy as np
import pandas as pd
import qiskit
import qiskit_aer
import scipy
from qiskit import QuantumCircuit, transpile
from qiskit.quantum_info import Statevector
from qiskit_aer import AerSimulator
from qiskit_aer.noise import (
    NoiseModel,
    amplitude_damping_error,
    depolarizing_error,
    phase_damping_error,
)
from scipy.special import rel_entr
from scipy.stats import chi2_contingency, chisquare

STATES = ["00", "01", "10", "11"]
EXPECTED = np.array([0.5, 0.0, 0.0, 0.5])
EPS = 1e-6
ONE_Q_GATES = ["h", "x", "y", "z", "s", "sdg", "t", "tdg"]
TWO_Q_GATES = ["cx", "cz", "swap"]

TEST_CASES = {
    "TC1": ("Base Combination", [("h", 0), ("cx", 0, 1)]),
    "TC2": ("Logical Equivalence", [("x", 0), ("h", 0), ("cx", 0, 1)]),
    "TC3": ("Single Phase Flip", [("z", 0), ("h", 0), ("cx", 0, 1)]),
    "TC4": ("Double Phase Flip", [("z", 0), ("z", 1), ("h", 0), ("cx", 0, 1)]),
    "TC5": ("Gate Invalidation", [("h", 0), ("cx", 0, 1), ("h", 0), ("h", 0)]),
    "TC6": ("Swap Operations", [("h", 1), ("cx", 1, 0)]),
}
NOISE_MODELS = {
    "depolarizing": "Depolarizing",
    "amplitude_damping": "Amplitude Damping",
    "phase_damping": "Phase Damping",
}
# 논문 설정: Depolarizing·AD → Z-기저, PD → X-기저
PAPER_BASIS = {"depolarizing": "Z", "amplitude_damping": "Z", "phase_damping": "X"}


# ---------------------------------------------------------------------------
def build_circuit(ops, basis="Z", measure=True):
    qc = QuantumCircuit(2, 2)
    for name, *qubits in ops:
        getattr(qc, name)(*qubits)
    if measure:
        if basis == "X":
            qc.barrier()
            qc.h([0, 1])
        qc.measure([0, 1], [0, 1])
    return qc


def ops_to_str(ops):
    return " -> ".join(f"{n.upper()}({','.join('q%d' % q for q in qs)})" for n, *qs in ops)


def ideal_probs(ops, basis="Z"):
    qc = build_circuit(ops, measure=False)
    if basis == "X":
        qc.h([0, 1])
    d = Statevector.from_instruction(qc).probabilities_dict()
    return np.array([d.get(s, 0.0) for s in STATES])


def create_noise_model(kind, p):
    if p <= 0:
        return None
    if kind == "depolarizing":
        e1, e2 = depolarizing_error(p, 1), depolarizing_error(p, 2)
    elif kind == "amplitude_damping":
        e1 = amplitude_damping_error(p)
        e2 = e1.tensor(e1)
    elif kind == "phase_damping":
        e1 = phase_damping_error(p)
        e2 = e1.tensor(e1)
    else:
        raise ValueError(kind)
    nm = NoiseModel()
    nm.add_all_qubit_quantum_error(e1, ONE_Q_GATES)
    nm.add_all_qubit_quantum_error(e2, TWO_Q_GATES)
    return nm


def simulate(qc, noise_model, shots, seed):
    backend = AerSimulator(noise_model=noise_model, seed_simulator=seed)
    tqc = transpile(qc, backend, optimization_level=0, seed_transpiler=seed)
    counts = backend.run(tqc, shots=shots, seed_simulator=seed).result().get_counts()
    return np.array([counts.get(s, 0) for s in STATES], dtype=float)


# ---------------------------------------------------------------------------
def chi_square_vs_expected(obs, expected=EXPECTED):
    pe = expected + EPS
    pe = pe / pe.sum()
    stat, p = chisquare(f_obs=obs, f_exp=pe * obs.sum())
    return float(stat), float(p)


def chi_square_vs_source(src, fol):
    table = np.vstack([src, fol])
    table = table[:, table.sum(axis=0) > 0]
    if table.shape[1] < 2:
        return 0.0, 1.0
    stat, p, _, _ = chi2_contingency(table, correction=False)
    return float(stat), float(p)


def kl_divergence(expected, obs):
    q = obs / obs.sum() + EPS
    return float(np.sum(rel_entr(expected, q / q.sum())))


def cosine_similarity(expected, obs):
    q = obs / obs.sum()
    return float(np.dot(expected, q) / (np.linalg.norm(expected) * np.linalg.norm(q)))


def judge(p):
    if p > 0.5:
        return "maintain"
    if p > 0.05:
        return "uncertain"
    return "collapse"


# ---------------------------------------------------------------------------
def main(argv=None):
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("--max-noise", type=float, default=0.1)
    ap.add_argument("--step", type=float, default=0.01)
    ap.add_argument("--shots", type=int, default=4096)
    ap.add_argument("--seeds", type=int, nargs="+", default=[1234])
    ap.add_argument("--bases", nargs="+", default=["Z", "X"], choices=["Z", "X"])
    ap.add_argument("--out", default="data")
    # parse_known_args: Jupyter/Colab 셀에서 실행할 때 커널이 넘기는 '-f ...' 인자를 무시
    args, _ = ap.parse_known_args(argv)

    os.makedirs(args.out, exist_ok=True)
    n = int(round(args.max_noise / args.step))
    levels = np.round(np.linspace(0, n * args.step, n + 1), 6)

    # 테스트 케이스 정의 표
    tc_rows = []
    for tc, (name, ops) in TEST_CASES.items():
        row = {"test_case": tc, "name": name, "circuit": ops_to_str(ops),
               "num_gates": len(ops), "num_2q_gates": sum(len(o) == 3 for o in ops)}
        for b in ["Z", "X"]:
            ip = ideal_probs(ops, b)
            row.update({f"ideal_{b}_p{s}": round(float(v), 6) for s, v in zip(STATES, ip)})
            row[f"mr_valid_ideal_{b}"] = bool(np.allclose(ip, ideal_probs(TEST_CASES["TC1"][1], b), atol=1e-9))
        tc_rows.append(row)
    pd.DataFrame(tc_rows).to_csv(os.path.join(args.out, "test_cases.csv"), index=False)

    rows = []
    total = len(args.seeds) * len(NOISE_MODELS) * len(args.bases) * len(levels) * len(TEST_CASES)
    t0, done = time.time(), 0
    src_ops = TEST_CASES["TC1"][1]
    for seed in args.seeds:
        for kind, kind_label in NOISE_MODELS.items():
            for basis in args.bases:
                # 이 기저에서의 기대 분포(TC1 이상적 분포). Z·X 모두 |00>,|11> 50%.
                expected = ideal_probs(src_ops, basis)
                for p in levels:
                    nm = create_noise_model(kind, float(p))
                    src_counts = simulate(build_circuit(src_ops, basis), nm, args.shots, seed)
                    for tc, (name, ops) in TEST_CASES.items():
                        counts = (src_counts if tc == "TC1"
                                  else simulate(build_circuit(ops, basis), nm, args.shots, seed))
                        probs = counts / counts.sum()
                        chi_e, p_e = chi_square_vs_expected(counts, expected)
                        chi_s, p_s = chi_square_vs_source(src_counts, counts)
                        rows.append({
                            "test_case": tc,
                            "test_case_name": name,
                            "noise_model": kind,
                            "noise_model_label": kind_label,
                            "basis": basis,
                            "paper_setting": basis == PAPER_BASIS[kind],
                            "noise_strength": float(p),
                            "shots": args.shots,
                            "seed": seed,
                            **{f"count_{s}": int(c) for s, c in zip(STATES, counts)},
                            **{f"prob_{s}": round(float(v), 6) for s, v in zip(STATES, probs)},
                            "error_state_prob": round(float(probs[1] + probs[2]), 6),
                            "chi2_expected": round(chi_e, 4),
                            "pvalue_expected": p_e,
                            "mr_expected": judge(p_e),
                            "chi2_vs_tc1": round(chi_s, 4),
                            "pvalue_vs_tc1": p_s,
                            "mr_vs_tc1": judge(p_s),
                            "kl_divergence": round(kl_divergence(expected, counts), 6),
                            "cosine_similarity": round(cosine_similarity(expected, counts), 6),
                        })
                        done += 1
                print(f"[{done}/{total}] seed={seed} {kind_label} {basis}-basis done "
                      f"({time.time() - t0:.1f}s)")

    df = pd.DataFrame(rows)
    path = os.path.join(args.out, "results.csv")
    df.to_csv(path, index=False)

    meta = {
        "description": "Metamorphic testing of 2-qubit gate combinations under quantum noise",
        "reference_doi": "10.9708/jksci.2026.31.05.001",
        "noise_levels": levels.tolist(),
        "shots": args.shots,
        "seeds": args.seeds,
        "bases": args.bases,
        "transpile_optimization_level": 0,
        "epsilon_for_zero_expected": EPS,
        "rows": len(df),
        "versions": {
            "python": platform.python_version(),
            "qiskit": qiskit.__version__,
            "qiskit_aer": qiskit_aer.__version__,
            "numpy": np.__version__,
            "scipy": scipy.__version__,
            "pandas": pd.__version__,
        },
        "generated_at": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
    }
    with open(os.path.join(args.out, "metadata.json"), "w", encoding="utf-8") as f:
        json.dump(meta, f, ensure_ascii=False, indent=2)

    print(f"\nSaved {len(df)} rows -> {path}")
    print(df[df.paper_setting].groupby(["noise_model", "test_case"])["kl_divergence"].max().unstack().round(4))


if __name__ == "__main__":
    main()