"""Execute physical dephasing on a continuous Hybrid state.

``NoiseModel`` selects a noisy-state engine instead of post-processing counts.
The result records the selected method, simulation classification, ordered
channel applications, and the same Hybrid state lineage used by ideal runs.
"""

from __future__ import annotations

import json

from cascaqit import (
    AHSProgram,
    AtomRegister,
    Circuit,
    HybridProgram,
    LocalBackend,
    Waveform,
)
from cascaqit.simulators import NoiseChannel, NoiseModel, SimulationOptions


def main() -> None:
    """Run a one-site D-A-D program with exact density-matrix dephasing."""
    analog = AHSProgram(
        AtomRegister.line(count=1, spacing=5.0),
        program_id="lesson.hybrid.noise.analog",
    ).drive(
        rabi=Waveform.constant(0.4, duration=0.1),
        detuning=Waveform.constant(0.0, duration=0.1),
        phase=0.0,
    )
    program = (
        HybridProgram("lesson.hybrid.noise")
        .digital("prepare", Circuit(1).h(0))
        .analog("evolve", analog)
        .digital("readout_rotation", Circuit(1).h(0))
        .measure_all()
    )
    noise = NoiseModel("lesson.hybrid.dephasing", (NoiseChannel.dephasing(0.3),))
    result = (
        LocalBackend(seed=104, analog_time_steps=4)
        .run(
            program,
            noise=noise,
            shots=32,
            options=SimulationOptions(
                method="density_matrix",
                integrator="fixed_step_krylov",
                max_steps=4,
            ),
        )
        .result()
    )
    report = result.metadata["noise_report"]

    ideal = LocalBackend(seed=104, analog_time_steps=4).run(program, shots=32).result()

    payload = {
        "track": "hybrid_researcher",
        "level": "advanced",
        "lesson": "physical_noise",
        "facts": {
            "method": result.metadata["simulation_execution_config"]["method"],
            "truthfulness": result.metadata["simulation_truthfulness"],
            "channel_types": report["applied_channel_types"],
            "noise_report_hash_present": len(result.metadata["noise_report_hash"])
            == 64,
            "probabilities": result.probabilities,
            "ideal_probabilities": ideal.probabilities,
            "physical_application_count": report["physical_application_count"],
            "measurement_application_count": report["measurement_application_count"],
            "counts_total": sum(result.counts.values()),
        },
        "boundaries": {
            "hardware_execution": False,
            "cloud_execution": False,
            "network_accessed": False,
            "credentials_loaded": False,
        },
    }
    print(json.dumps(payload, sort_keys=True))


if __name__ == "__main__":
    main()