SDR-Rover/experiments/lab029_packet_channel_simulation.py

"""
Lab029. Monte Carlo simulation of Lab028 video packets over impaired channels.

Real synchronous BASE and ROI JPEGs are formed with the Lab028 working
profile. The existing 32-byte packet format, packet CRC32, object CRC32, and
atomic CompositeReassembler are used unchanged. JPEGs and packets remain in
memory; only aggregate CSV, text, and PNG results are written.
"""

from __future__ import annotations

import csv
from dataclasses import asdict, dataclass
from pathlib import Path
from typing import Callable

import cv2
import matplotlib
import numpy as np

matplotlib.use("Agg")
import matplotlib.pyplot as plt

from protocol.video_packet import (
    CompositeReassembler,
    ObjectType,
    PacketCRCError,
    VideoPacketError,
)
from experiments.lab028_video_packetization import (
    EncodedComposite,
    SOURCE_VIDEO_PATH,
    VideoMetadata,
    load_video_profile,
    packets_for_composite,
)


OUTPUT_DIRECTORY = Path("data/processed/lab029")
CSV_PATH = OUTPUT_DIRECTORY / "lab029_results.csv"
REPORT_PATH = OUTPUT_DIRECTORY / "lab029_report.txt"
INDEPENDENT_PLOT_PATH = (
    OUTPUT_DIRECTORY / "lab029_independent_loss_success.png"
)
BER_PLOT_PATH = OUTPUT_DIRECTORY / "lab029_ber_success.png"
BURST_PLOT_PATH = OUTPUT_DIRECTORY / "lab029_burst_loss_results.png"
PAYLOAD_COMPARISON_PLOT_PATH = (
    OUTPUT_DIRECTORY / "lab029_payload_comparison.png"
)

PAYLOAD_SIZES = (256, 512, 1024)
PACKET_LOSS_PROBABILITIES = (0.0, 0.001, 0.005, 0.01, 0.02, 0.05)
BER_VALUES = (0.0, 1e-7, 3e-7, 1e-6, 3e-6, 1e-5)
MONTE_CARLO_REPETITIONS = 200
MASTER_SEED = 29029
INDEPENDENT_SEED_BASE = MASTER_SEED
BER_SEED_BASE = MASTER_SEED + 1000
BURST_SEED_BASE = MASTER_SEED + 2000
BURST_STATIONARY_LOSS_PROBABILITY = 0.02

BURST_DISTRIBUTION_LABELS = (
    "1",
    "2",
    "3-4",
    "5-8",
    "9-16",
    "17-32",
    "33+",
)

CSV_FIELDS = [
    "model",
    "parameter_name",
    "parameter_value",
    "scenario",
    "payload_size",
    "monte_carlo_repetitions",
    "seed",
    "good_to_bad_probability",
    "bad_to_good_probability",
    "expected_loss_probability",
    "expected_mean_loss_burst",
    "observed_loss_probability",
    "transmitted_packets",
    "received_packets",
    "lost_packets",
    "crc_rejected_packets",
    "packet_delivery_rate",
    "base_objects_completed",
    "roi_objects_completed",
    "atomic_composite_frames_completed",
    "base_only_frames",
    "roi_only_frames",
    "incomplete_frames",
    "composite_success_rate",
    "effective_delivered_jpeg_bitrate_kbps",
    "mean_lost_fragments_per_frame",
    "p95_lost_fragments_per_frame",
    "mean_loss_burst_length",
    "max_loss_burst_length",
    "loss_burst_distribution",
]


@dataclass(frozen=True)
class BurstScenario:
    name: str
    description: str
    expected_mean_burst: float
    good_to_bad_probability: float
    bad_to_good_probability: float


@dataclass(frozen=True)
class PreparedFrame:
    composite_frame_id: int
    base_jpeg_size: int
    roi_jpeg_size: int
    packets: tuple[bytes, ...]


@dataclass(frozen=True)
class PreparedPacket:
    composite_frame_id: int
    wire_packet: bytes


@dataclass(frozen=True)
class PreparedProfile:
    payload_size: int
    frames: tuple[PreparedFrame, ...]
    packets: tuple[PreparedPacket, ...]


@dataclass(frozen=True)
class SimulationResult:
    model: str
    parameter_name: str
    parameter_value: float
    scenario: str
    payload_size: int
    monte_carlo_repetitions: int
    seed: int
    good_to_bad_probability: float
    bad_to_good_probability: float
    expected_loss_probability: float
    expected_mean_loss_burst: float
    observed_loss_probability: float
    transmitted_packets: int
    received_packets: int
    lost_packets: int
    crc_rejected_packets: int
    packet_delivery_rate: float
    base_objects_completed: int
    roi_objects_completed: int
    atomic_composite_frames_completed: int
    base_only_frames: int
    roi_only_frames: int
    incomplete_frames: int
    composite_success_rate: float
    effective_delivered_jpeg_bitrate_kbps: float
    mean_lost_fragments_per_frame: float
    p95_lost_fragments_per_frame: float
    mean_loss_burst_length: float
    max_loss_burst_length: int
    loss_burst_distribution: str


@dataclass(frozen=True)
class FunctionalTestResult:
    name: str
    passed: bool
    detail: str


def build_burst_scenarios() -> tuple[BurstScenario, ...]:
    """
    Build three loss-only Gilbert-Elliott scenarios.

    Good packets are delivered and Bad packets are lost. All scenarios have
    the same stationary Bad probability of 2%, while mean Bad-state duration
    changes from 2 to 20 packets.
    """

    scenarios = []
    definitions = (
        ("short", "короткие серии потерь", 2.0),
        ("medium", "средние серии потерь", 5.0),
        ("long", "длинные серии потерь", 20.0),
    )
    for name, description, mean_burst in definitions:
        bad_to_good = 1.0 / mean_burst
        good_to_bad = (
            BURST_STATIONARY_LOSS_PROBABILITY
            * bad_to_good
            / (1.0 - BURST_STATIONARY_LOSS_PROBABILITY)
        )
        scenarios.append(
            BurstScenario(
                name=name,
                description=description,
                expected_mean_burst=mean_burst,
                good_to_bad_probability=good_to_bad,
                bad_to_good_probability=bad_to_good,
            )
        )
    return tuple(scenarios)


BURST_SCENARIOS = build_burst_scenarios()


def prepare_profiles(
    composites: list[EncodedComposite],
) -> dict[int, PreparedProfile]:
    """Packetize every real JPEG once for each investigated payload size."""

    profiles = {}
    for payload_size in PAYLOAD_SIZES:
        frames = []
        flattened_packets = []
        for composite in composites:
            base_packets, roi_packets = packets_for_composite(
                composite, payload_size
            )
            packets = tuple(base_packets + roi_packets)
            frame = PreparedFrame(
                composite_frame_id=composite.composite_frame_id,
                base_jpeg_size=len(composite.base_jpeg),
                roi_jpeg_size=len(composite.roi_jpeg),
                packets=packets,
            )
            frames.append(frame)
            flattened_packets.extend(
                PreparedPacket(
                    composite_frame_id=composite.composite_frame_id,
                    wire_packet=packet,
                )
                for packet in packets
            )
        profiles[payload_size] = PreparedProfile(
            payload_size=payload_size,
            frames=tuple(frames),
            packets=tuple(flattened_packets),
        )
    return profiles


def burst_distribution_bin(length: int) -> str:
    if length == 1:
        return "1"
    if length == 2:
        return "2"
    if length <= 4:
        return "3-4"
    if length <= 8:
        return "5-8"
    if length <= 16:
        return "9-16"
    if length <= 32:
        return "17-32"
    return "33+"


def format_burst_distribution(lengths: list[int]) -> str:
    counts = {label: 0 for label in BURST_DISTRIBUTION_LABELS}
    for length in lengths:
        counts[burst_distribution_bin(length)] += 1
    return ";".join(
        f"{label}:{counts[label]}"
        for label in BURST_DISTRIBUTION_LABELS
    )


def corrupt_packet_bits(
    wire_packet: bytes,
    error_count: int,
    rng: np.random.Generator,
) -> bytes:
    """Flip independently selected bit positions in a packet copy."""

    if error_count <= 0:
        return wire_packet
    bit_count = len(wire_packet) * 8
    error_count = min(error_count, bit_count)
    positions = rng.choice(
        bit_count,
        size=error_count,
        replace=False,
    )
    corrupted = bytearray(wire_packet)
    for position in np.atleast_1d(positions):
        bit_position = int(position)
        byte_index, bit_index = divmod(bit_position, 8)
        corrupted[byte_index] ^= 1 << bit_index
    return bytes(corrupted)


def independent_loss_flags(
    packet_count: int,
    loss_probability: float,
    rng: np.random.Generator,
) -> np.ndarray:
    return rng.random(packet_count) < loss_probability


def ber_error_counts(
    profile: PreparedProfile,
    ber: float,
    rng: np.random.Generator,
) -> np.ndarray:
    bit_lengths = np.fromiter(
        (
            len(packet.wire_packet) * 8
            for packet in profile.packets
        ),
        dtype=np.int64,
        count=len(profile.packets),
    )
    return rng.binomial(bit_lengths, ber)


def burst_loss_flags(
    packet_count: int,
    scenario: BurstScenario,
    rng: np.random.Generator,
) -> np.ndarray:
    """Generate one stationary two-state Good/Bad packet sequence."""

    flags = np.zeros(packet_count, dtype=np.bool_)
    bad_state = (
        rng.random() < BURST_STATIONARY_LOSS_PROBABILITY
    )
    for index in range(packet_count):
        flags[index] = bad_state
        transition_sample = rng.random()
        if bad_state:
            if transition_sample < scenario.bad_to_good_probability:
                bad_state = False
        elif transition_sample < scenario.good_to_bad_probability:
            bad_state = True
    return flags


def simulate_condition(
    profile: PreparedProfile,
    metadata: VideoMetadata,
    model: str,
    parameter_name: str,
    parameter_value: float,
    seed: int,
    repetitions: int,
    scenario: BurstScenario | None = None,
) -> SimulationResult:
    """Simulate one channel condition and aggregate all requested metrics."""

    if repetitions <= 0:
        raise ValueError("repetitions must be positive")
    if model == "burst" and scenario is None:
        raise ValueError("burst model requires a scenario")
    if model not in {"independent_loss", "ber", "burst"}:
        raise ValueError(f"unsupported model: {model}")

    rng = np.random.default_rng(seed)
    transmitted_packets = 0
    received_packets = 0
    lost_packets = 0
    crc_rejected_packets = 0
    base_objects_completed = 0
    roi_objects_completed = 0
    atomic_composite_frames_completed = 0
    base_only_frames = 0
    roi_only_frames = 0
    incomplete_frames = 0
    delivered_atomic_jpeg_bytes = 0
    lost_fragments_per_frame: list[int] = []
    loss_burst_lengths: list[int] = []

    packet_count = len(profile.packets)
    frame_count = len(profile.frames)
    jpeg_sizes_by_id = {
        frame.composite_frame_id: (
            frame.base_jpeg_size + frame.roi_jpeg_size
        )
        for frame in profile.frames
    }

    for _ in range(repetitions):
        receiver = CompositeReassembler()
        completed_frame_ids: set[int] = set()
        unavailable_by_frame = [0] * frame_count
        current_loss_burst = 0

        if model == "independent_loss":
            loss_flags = independent_loss_flags(
                packet_count, parameter_value, rng
            )
            error_counts = None
        elif model == "ber":
            loss_flags = np.zeros(packet_count, dtype=np.bool_)
            error_counts = ber_error_counts(profile, parameter_value, rng)
        else:
            assert scenario is not None
            loss_flags = burst_loss_flags(packet_count, scenario, rng)
            error_counts = None

        for packet_index, prepared_packet in enumerate(profile.packets):
            transmitted_packets += 1
            frame_id = prepared_packet.composite_frame_id

            if bool(loss_flags[packet_index]):
                lost_packets += 1
                unavailable_by_frame[frame_id] += 1
                current_loss_burst += 1
                continue

            received_packets += 1
            wire_packet = prepared_packet.wire_packet
            if error_counts is not None:
                error_count = int(error_counts[packet_index])
                if error_count > 0:
                    wire_packet = corrupt_packet_bits(
                        wire_packet, error_count, rng
                    )

            try:
                completed = receiver.ingest(wire_packet)
            except VideoPacketError:
                crc_rejected_packets += 1
                unavailable_by_frame[frame_id] += 1
                current_loss_burst += 1
                continue

            if current_loss_burst:
                loss_burst_lengths.append(current_loss_burst)
                current_loss_burst = 0

            if completed is not None:
                completed_frame_ids.add(completed.composite_frame_id)
                atomic_composite_frames_completed += 1
                delivered_atomic_jpeg_bytes += (
                    len(completed.base_jpeg) + len(completed.roi_jpeg)
                )

        if current_loss_burst:
            loss_burst_lengths.append(current_loss_burst)

        for frame in profile.frames:
            frame_id = frame.composite_frame_id
            atomic_complete = frame_id in completed_frame_ids
            base_complete = (
                atomic_complete
                or receiver.object_is_complete(frame_id, ObjectType.BASE)
            )
            roi_complete = (
                atomic_complete
                or receiver.object_is_complete(frame_id, ObjectType.ROI)
            )
            base_objects_completed += int(base_complete)
            roi_objects_completed += int(roi_complete)
            base_only_frames += int(base_complete and not roi_complete)
            roi_only_frames += int(roi_complete and not base_complete)
            incomplete_frames += int(not atomic_complete)

        lost_fragments_per_frame.extend(unavailable_by_frame)

    expected_frames = frame_count * repetitions
    if (
        atomic_composite_frames_completed
        + incomplete_frames
        != expected_frames
    ):
        raise RuntimeError("atomic and incomplete frame counts disagree")
    if base_objects_completed != (
        atomic_composite_frames_completed + base_only_frames
    ):
        raise RuntimeError("BASE completion accounting disagrees")
    if roi_objects_completed != (
        atomic_composite_frames_completed + roi_only_frames
    ):
        raise RuntimeError("ROI completion accounting disagrees")

    unavailable_packets = lost_packets + crc_rejected_packets
    accepted_packets = received_packets - crc_rejected_packets
    observed_loss_probability = (
        unavailable_packets / transmitted_packets
    )
    if model == "burst":
        assert scenario is not None
        scenario_name = scenario.name
        good_to_bad = scenario.good_to_bad_probability
        bad_to_good = scenario.bad_to_good_probability
        expected_loss = BURST_STATIONARY_LOSS_PROBABILITY
        expected_mean_burst = scenario.expected_mean_burst
    elif model == "independent_loss":
        scenario_name = ""
        good_to_bad = 0.0
        bad_to_good = 0.0
        expected_loss = parameter_value
        expected_mean_burst = (
            0.0 if parameter_value == 0.0
            else 1.0 / (1.0 - parameter_value)
        )
    else:
        scenario_name = ""
        good_to_bad = 0.0
        bad_to_good = 0.0
        expected_loss = 0.0
        expected_mean_burst = 0.0

    total_simulated_duration = (
        metadata.duration_seconds * repetitions
    )
    return SimulationResult(
        model=model,
        parameter_name=parameter_name,
        parameter_value=parameter_value,
        scenario=scenario_name,
        payload_size=profile.payload_size,
        monte_carlo_repetitions=repetitions,
        seed=seed,
        good_to_bad_probability=good_to_bad,
        bad_to_good_probability=bad_to_good,
        expected_loss_probability=expected_loss,
        expected_mean_loss_burst=expected_mean_burst,
        observed_loss_probability=observed_loss_probability,
        transmitted_packets=transmitted_packets,
        received_packets=received_packets,
        lost_packets=lost_packets,
        crc_rejected_packets=crc_rejected_packets,
        packet_delivery_rate=accepted_packets / transmitted_packets,
        base_objects_completed=base_objects_completed,
        roi_objects_completed=roi_objects_completed,
        atomic_composite_frames_completed=(
            atomic_composite_frames_completed
        ),
        base_only_frames=base_only_frames,
        roi_only_frames=roi_only_frames,
        incomplete_frames=incomplete_frames,
        composite_success_rate=(
            atomic_composite_frames_completed / expected_frames
        ),
        effective_delivered_jpeg_bitrate_kbps=(
            delivered_atomic_jpeg_bytes
            * 8.0
            / total_simulated_duration
            / 1000.0
        ),
        mean_lost_fragments_per_frame=float(
            np.mean(lost_fragments_per_frame)
        ),
        p95_lost_fragments_per_frame=float(
            np.percentile(lost_fragments_per_frame, 95)
        ),
        mean_loss_burst_length=(
            float(np.mean(loss_burst_lengths))
            if loss_burst_lengths
            else 0.0
        ),
        max_loss_burst_length=(
            max(loss_burst_lengths) if loss_burst_lengths else 0
        ),
        loss_burst_distribution=format_burst_distribution(
            loss_burst_lengths
        ),
    )


def run_monte_carlo(
    profiles: dict[int, PreparedProfile],
    metadata: VideoMetadata,
) -> list[SimulationResult]:
    """Run all 45 channel/payload combinations."""

    results = []
    for parameter_index, loss_probability in enumerate(
        PACKET_LOSS_PROBABILITIES
    ):
        seed = INDEPENDENT_SEED_BASE + parameter_index
        for payload_size in PAYLOAD_SIZES:
            results.append(
                simulate_condition(
                    profiles[payload_size],
                    metadata,
                    model="independent_loss",
                    parameter_name="packet_loss_probability",
                    parameter_value=loss_probability,
                    seed=seed,
                    repetitions=MONTE_CARLO_REPETITIONS,
                )
            )

    for parameter_index, ber in enumerate(BER_VALUES):
        seed = BER_SEED_BASE + parameter_index
        for payload_size in PAYLOAD_SIZES:
            results.append(
                simulate_condition(
                    profiles[payload_size],
                    metadata,
                    model="ber",
                    parameter_name="bit_error_rate",
                    parameter_value=ber,
                    seed=seed,
                    repetitions=MONTE_CARLO_REPETITIONS,
                )
            )

    for scenario_index, scenario in enumerate(BURST_SCENARIOS):
        seed = BURST_SEED_BASE + scenario_index
        for payload_size in PAYLOAD_SIZES:
            results.append(
                simulate_condition(
                    profiles[payload_size],
                    metadata,
                    model="burst",
                    parameter_name="gilbert_elliott_scenario",
                    parameter_value=float(scenario_index),
                    seed=seed,
                    repetitions=MONTE_CARLO_REPETITIONS,
                    scenario=scenario,
                )
            )
    return results


def run_functional_tests(
    composites: list[EncodedComposite],
    profiles: dict[int, PreparedProfile],
    metadata: VideoMetadata,
    results: list[SimulationResult],
) -> list[FunctionalTestResult]:
    """Verify zero impairment, CRC, isolation, atomicity, and repeatability."""

    tests: list[tuple[str, Callable[[], str]]] = []

    def zero_impairment_is_perfect() -> str:
        zero_rows = [
            result
            for result in results
            if (
                result.model in {"independent_loss", "ber"}
                and result.parameter_value == 0.0
            )
        ]
        if len(zero_rows) != len(PAYLOAD_SIZES) * 2:
            raise AssertionError("zero-impairment rows are missing")
        for row in zero_rows:
            if (
                row.packet_delivery_rate != 1.0
                or row.composite_success_rate != 1.0
                or row.incomplete_frames != 0
            ):
                raise AssertionError(
                    f"zero impairment failed for {row.model}/"
                    f"{row.payload_size}"
                )
        return "all payloads delivered 100% packets and composite frames"

    def crc_rejects_corruption() -> str:
        packet = profiles[512].packets[0].wire_packet
        corrupted = bytearray(packet)
        corrupted[-1] ^= 0x01
        try:
            CompositeReassembler().ingest(bytes(corrupted))
        except PacketCRCError:
            return "payload bit flip was rejected by packet CRC32"
        raise AssertionError("corrupted packet was not rejected by CRC")

    def adjacent_frames_do_not_mix() -> str:
        first_profile_frames = profiles[512].frames[:2]
        interleaved = []
        first_packets = first_profile_frames[0].packets
        second_packets = first_profile_frames[1].packets
        for index in range(max(len(first_packets), len(second_packets))):
            if index < len(second_packets):
                interleaved.append(second_packets[index])
            if index < len(first_packets):
                interleaved.append(first_packets[index])
        receiver = CompositeReassembler()
        completed = {}
        for packet in interleaved:
            frame = receiver.ingest(packet)
            if frame is not None:
                completed[frame.composite_frame_id] = frame
        expected = {composites[0].composite_frame_id, composites[1].composite_frame_id}
        if set(completed) != expected:
            raise AssertionError("adjacent frame IDs were mixed or lost")
        for composite in composites[:2]:
            frame = completed[composite.composite_frame_id]
            if (
                frame.base_jpeg != composite.base_jpeg
                or frame.roi_jpeg != composite.roi_jpeg
            ):
                raise AssertionError("neighboring JPEG objects were mixed")
        return "two interleaved neighboring frames remained independent"

    def incomplete_frame_is_not_published() -> str:
        frame = profiles[512].frames[0]
        receiver = CompositeReassembler()
        completed_count = 0
        for packet in frame.packets[:-1]:
            if receiver.ingest(packet) is not None:
                completed_count += 1
        if completed_count != 0:
            raise AssertionError("incomplete composite frame was published")
        if not receiver.object_is_complete(
            frame.composite_frame_id, ObjectType.BASE
        ):
            raise AssertionError("complete BASE object was not retained")
        return "missing ROI fragment prevented atomic publication"

    def identical_seed_is_reproducible() -> str:
        short_profile = PreparedProfile(
            payload_size=512,
            frames=profiles[512].frames[:2],
            packets=tuple(
                packet
                for packet in profiles[512].packets
                if packet.composite_frame_id < 2
            ),
        )
        first = simulate_condition(
            short_profile,
            metadata,
            model="independent_loss",
            parameter_name="packet_loss_probability",
            parameter_value=0.02,
            seed=MASTER_SEED + 9999,
            repetitions=5,
        )
        second = simulate_condition(
            short_profile,
            metadata,
            model="independent_loss",
            parameter_name="packet_loss_probability",
            parameter_value=0.02,
            seed=MASTER_SEED + 9999,
            repetitions=5,
        )
        if first != second:
            raise AssertionError("same seed produced different aggregates")
        return "identical seed produced byte-for-byte equal result fields"

    tests.extend(
        [
            ("zero_impairment_100_percent", zero_impairment_is_perfect),
            ("packet_crc_rejects_bit_error", crc_rejects_corruption),
            ("adjacent_frame_isolation", adjacent_frames_do_not_mix),
            ("atomic_incomplete_frame", incomplete_frame_is_not_published),
            ("fixed_seed_reproducibility", identical_seed_is_reproducible),
        ]
    )

    test_results = []
    for name, test in tests:
        try:
            detail = test()
        except Exception as error:
            test_results.append(
                FunctionalTestResult(name, False, str(error))
            )
        else:
            test_results.append(
                FunctionalTestResult(name, True, detail)
            )
    failed = [result for result in test_results if not result.passed]
    if failed:
        details = "; ".join(
            f"{result.name}: {result.detail}" for result in failed
        )
        raise RuntimeError(f"Lab029 functional checks failed: {details}")
    return test_results


def result_lookup(
    results: list[SimulationResult],
    model: str,
    parameter_value: float | None = None,
    scenario: str | None = None,
) -> dict[int, SimulationResult]:
    matches = [
        result
        for result in results
        if (
            result.model == model
            and (
                parameter_value is None
                or result.parameter_value == parameter_value
            )
            and (scenario is None or result.scenario == scenario)
        )
    ]
    return {result.payload_size: result for result in matches}


def save_csv(results: list[SimulationResult]) -> None:
    OUTPUT_DIRECTORY.mkdir(parents=True, exist_ok=True)
    with CSV_PATH.open("w", encoding="utf-8", newline="") as csv_file:
        writer = csv.DictWriter(csv_file, fieldnames=CSV_FIELDS)
        writer.writeheader()
        for result in results:
            raw_row = asdict(result)
            row = {}
            for field_name in CSV_FIELDS:
                value = raw_row[field_name]
                row[field_name] = (
                    f"{value:.12g}"
                    if isinstance(value, float)
                    else value
                )
            writer.writerow(row)


def save_independent_plot(results: list[SimulationResult]) -> None:
    figure, axis = plt.subplots(figsize=(9, 5.5))
    loss_percentages = [
        probability * 100.0
        for probability in PACKET_LOSS_PROBABILITIES
    ]
    for payload_size in PAYLOAD_SIZES:
        success = [
            result_lookup(
                results, "independent_loss", probability
            )[payload_size].composite_success_rate
            * 100.0
            for probability in PACKET_LOSS_PROBABILITIES
        ]
        axis.plot(
            loss_percentages,
            success,
            marker="o",
            linewidth=2,
            label=f"payload {payload_size} B",
        )
    axis.set_xlabel("Independent packet loss probability, %")
    axis.set_ylabel("Atomic composite success rate, %")
    axis.set_title("Lab029 independent packet loss")
    axis.grid(True, alpha=0.3)
    axis.legend()
    figure.tight_layout()
    figure.savefig(INDEPENDENT_PLOT_PATH, dpi=160)
    plt.close(figure)


def save_ber_plot(results: list[SimulationResult]) -> None:
    figure, axis = plt.subplots(figsize=(9, 5.5))
    x_values = [1e-8 if ber == 0.0 else ber for ber in BER_VALUES]
    for payload_size in PAYLOAD_SIZES:
        success = [
            result_lookup(results, "ber", ber)[
                payload_size
            ].composite_success_rate
            * 100.0
            for ber in BER_VALUES
        ]
        axis.plot(
            x_values,
            success,
            marker="o",
            linewidth=2,
            label=f"payload {payload_size} B",
        )
    axis.set_xscale("log")
    axis.set_xticks(x_values)
    axis.set_xticklabels(
        ["0", "1e-7", "3e-7", "1e-6", "3e-6", "1e-5"]
    )
    axis.set_xlabel("Bit error rate (zero shown at 1e-8 position)")
    axis.set_ylabel("Atomic composite success rate, %")
    axis.set_title("Lab029 independent bit errors")
    axis.grid(True, which="both", alpha=0.3)
    axis.legend()
    figure.tight_layout()
    figure.savefig(BER_PLOT_PATH, dpi=160)
    plt.close(figure)


def save_burst_plot(results: list[SimulationResult]) -> None:
    figure, axis = plt.subplots(figsize=(9, 5.5))
    x_positions = np.arange(len(BURST_SCENARIOS))
    for payload_size in PAYLOAD_SIZES:
        success = [
            result_lookup(
                results, "burst", scenario=scenario.name
            )[payload_size].composite_success_rate
            * 100.0
            for scenario in BURST_SCENARIOS
        ]
        axis.plot(
            x_positions,
            success,
            marker="o",
            linewidth=2,
            label=f"payload {payload_size} B",
        )
    axis.set_xticks(x_positions)
    axis.set_xticklabels(
        [
            f"{scenario.name}\nmean {scenario.expected_mean_burst:g}"
            for scenario in BURST_SCENARIOS
        ]
    )
    axis.set_xlabel("Gilbert-Elliott loss scenario")
    axis.set_ylabel("Atomic composite success rate, %")
    axis.set_title(
        "Lab029 burst loss at 2% stationary packet loss"
    )
    axis.grid(True, alpha=0.3)
    axis.legend()
    figure.tight_layout()
    figure.savefig(BURST_PLOT_PATH, dpi=160)
    plt.close(figure)


def save_payload_comparison_plot(
    results: list[SimulationResult],
) -> None:
    conditions = [
        (
            "Loss 1%",
            result_lookup(results, "independent_loss", 0.01),
        ),
        ("BER 1e-6", result_lookup(results, "ber", 1e-6)),
        (
            "Burst medium",
            result_lookup(results, "burst", scenario="medium"),
        ),
    ]
    x_positions = np.arange(len(conditions))
    bar_width = 0.24
    figure, axis = plt.subplots(figsize=(9, 5.5))
    for payload_index, payload_size in enumerate(PAYLOAD_SIZES):
        values = [
            condition_results[payload_size].composite_success_rate
            * 100.0
            for _, condition_results in conditions
        ]
        axis.bar(
            x_positions
            + (payload_index - 1) * bar_width,
            values,
            width=bar_width,
            label=f"payload {payload_size} B",
        )
    axis.set_xticks(x_positions)
    axis.set_xticklabels([name for name, _ in conditions])
    axis.set_ylabel("Atomic composite success rate, %")
    axis.set_title("Lab029 payload comparison")
    axis.grid(True, axis="y", alpha=0.3)
    axis.legend()
    figure.tight_layout()
    figure.savefig(PAYLOAD_COMPARISON_PLOT_PATH, dpi=160)
    plt.close(figure)


def save_plots(results: list[SimulationResult]) -> None:
    save_independent_plot(results)
    save_ber_plot(results)
    save_burst_plot(results)
    save_payload_comparison_plot(results)


def success_matrix_lines(
    results: list[SimulationResult],
    model: str,
    parameters: tuple[float, ...],
    parameter_formatter: Callable[[float], str],
) -> list[str]:
    lines = [
        "parameter | payload 256 | payload 512 | payload 1024",
        "---------:|------------:|------------:|-------------:",
    ]
    for parameter in parameters:
        by_payload = result_lookup(results, model, parameter)
        lines.append(
            f"{parameter_formatter(parameter)} | "
            f"{by_payload[256].composite_success_rate * 100.0:.3f}% | "
            f"{by_payload[512].composite_success_rate * 100.0:.3f}% | "
            f"{by_payload[1024].composite_success_rate * 100.0:.3f}%"
        )
    return lines


def burst_table_lines(
    results: list[SimulationResult],
) -> list[str]:
    lines = [
        (
            "scenario | payload | expected loss | observed loss | "
            "mean/max burst | composite success | burst distribution"
        ),
        (
            "--------:|--------:|--------------:|--------------:|"
            "---------------:|------------------:|:------------------"
        ),
    ]
    for scenario in BURST_SCENARIOS:
        by_payload = result_lookup(
            results, "burst", scenario=scenario.name
        )
        for payload_size in PAYLOAD_SIZES:
            result = by_payload[payload_size]
            lines.append(
                f"{scenario.name} | {payload_size} | "
                f"{result.expected_loss_probability * 100.0:.3f}% | "
                f"{result.observed_loss_probability * 100.0:.3f}% | "
                f"{result.mean_loss_burst_length:.3f}/"
                f"{result.max_loss_burst_length} | "
                f"{result.composite_success_rate * 100.0:.3f}% | "
                f"{result.loss_burst_distribution}"
            )
    return lines


def comparison_table_lines(
    results: list[SimulationResult],
) -> list[str]:
    loss = result_lookup(results, "independent_loss", 0.01)
    ber = result_lookup(results, "ber", 1e-6)
    burst = result_lookup(results, "burst", scenario="medium")
    lines = [
        (
            "payload | loss 1% success | BER 1e-6 success | "
            "medium burst success | Lab028 wire kbit/s"
        ),
        (
            "-------:|----------------:|-----------------:|"
            "---------------------:|--------------------:"
        ),
    ]
    lab028_wire_bitrate = {
        256: 178.233323,
        512: 168.396019,
        1024: 163.662279,
    }
    for payload_size in PAYLOAD_SIZES:
        lines.append(
            f"{payload_size} | "
            f"{loss[payload_size].composite_success_rate * 100.0:.3f}% | "
            f"{ber[payload_size].composite_success_rate * 100.0:.3f}% | "
            f"{burst[payload_size].composite_success_rate * 100.0:.3f}% | "
            f"{lab028_wire_bitrate[payload_size]:.3f}"
        )
    return lines


def write_report(
    metadata: VideoMetadata,
    composites: list[EncodedComposite],
    profiles: dict[int, PreparedProfile],
    results: list[SimulationResult],
    functional_tests: list[FunctionalTestResult],
) -> None:
    lines = [
        "Lab029. Прохождение видеопакетов через канал с потерями и ошибками",
        "",
        "Исходные данные и неизменный транспорт Lab028",
        f"- Видео: {SOURCE_VIDEO_PATH}",
        (
            f"- Источник: {metadata.width}x{metadata.height}, "
            f"{metadata.fps:.6f} fps, {metadata.frame_count} кадров, "
            f"{metadata.duration_seconds:.6f} с."
        ),
        (
            f"- Реальных синхронных JPEG-пар: {len(composites)}; "
            "BASE 240x135 grayscale Q23, ROI 320x180 grayscale Q33, "
            "3 composite fps."
        ),
        (
            "- Использован protocol/video_packet.py без изменения: "
            "32-byte header, packet CRC32, object CRC32, отдельные BASE/ROI "
            "и атомарная выдача CompositeReassembler."
        ),
        (
            "- Payload: "
            + ", ".join(str(value) for value in PAYLOAD_SIZES)
            + " байт."
        ),
        (
            "- Пакетов в одном проходе: "
            + ", ".join(
                f"{payload} B={len(profiles[payload].packets)}"
                for payload in PAYLOAD_SIZES
            )
            + "."
        ),
        "",
        "Методика Monte Carlo",
        f"- Повторов на каждую строку: {MONTE_CARLO_REPETITIONS}.",
        (
            f"- Master seed: {MASTER_SEED}; independent seeds "
            f"{INDEPENDENT_SEED_BASE}...{INDEPENDENT_SEED_BASE + 5}; "
            f"BER seeds {BER_SEED_BASE}...{BER_SEED_BASE + 5}; "
            f"burst seeds {BURST_SEED_BASE}...{BURST_SEED_BASE + 2}."
        ),
        (
            "- Для одинакового параметра один seed повторно используется "
            "для payload 256/512/1024, чтобы сравнение было коррелированным "
            "и воспроизводимым."
        ),
        (
            "- packet_delivery_rate = (received - CRC rejected) / "
            "transmitted."
        ),
        (
            "- effective delivered JPEG bitrate учитывает BASE+ROI bytes "
            "только атомарно выданных составных кадров и полное "
            "симулированное время."
        ),
        (
            "- Потерянный фрагмент — физически потерянный пакет или пакет, "
            "отклонённый проверкой транспорта."
        ),
        (
            "- FEC, ARQ, повторные передачи и интерливинг не применяются."
        ),
        "",
        "Модели канала",
        (
            "- Independent loss: каждый пакет теряется независимо с "
            "заданной вероятностью."
        ),
        (
            "- BER: число независимых битовых ошибок выбирается binomial "
            "по полной длине пакета в битах, включая 32-byte header; "
            "выбранные биты физически инвертируются перед reassembler."
        ),
        (
            "- Gilbert-Elliott: Good доставляет все пакеты, Bad теряет все. "
            "Начальное состояние выбирается из стационарного распределения."
        ),
        (
            "- В Lab029 длительность состояния Bad и серии потерь задаётся "
            "количеством пакетов, а не физическим временем."
        ),
        (
            "- Серия из одинакового количества пакетов имеет разную "
            "физическую длительность для payload 256, 512 и 1024 байта, "
            "поскольку различается время передачи пакета."
        ),
        (
            "- Доля успешно восстановленных кадров не показывает "
            "длительность непрерывного отсутствия нового изображения."
        ),
        (
            "- Поэтому burst-loss результаты Lab029 не являются "
            "окончательным сравнением размеров payload; для временного "
            "сравнения предназначена Lab029B."
        ),
    ]
    for scenario in BURST_SCENARIOS:
        lines.append(
            f"  - {scenario.name}: {scenario.description}; "
            f"P(G->B)={scenario.good_to_bad_probability:.9f}, "
            f"P(B->G)={scenario.bad_to_good_probability:.9f}, "
            f"stationary loss={BURST_STATIONARY_LOSS_PROBABILITY:.3%}, "
            f"expected mean burst={scenario.expected_mean_burst:.1f}."
        )

    lines.extend(["", "Функциональные проверки"])
    lines.extend(
        f"- {'PASS' if test.passed else 'FAIL'} {test.name}: {test.detail}"
        for test in functional_tests
    )
    lines.extend(
        [
            "",
            "1. Independent packet loss — atomic composite success",
            *success_matrix_lines(
                results,
                "independent_loss",
                PACKET_LOSS_PROBABILITIES,
                lambda value: f"{value * 100.0:.1f}%",
            ),
            "",
            "2. BER — atomic composite success",
            *success_matrix_lines(
                results,
                "ber",
                BER_VALUES,
                lambda value: "0" if value == 0.0 else f"{value:.0e}",
            ),
            "",
            "3. Burst-loss",
            *burst_table_lines(results),
            "",
            "4. Сравнение payload 256/512/1024",
            *comparison_table_lines(results),
            "",
            "Интерпретация",
            (
                "- При фиксированной вероятности потери пакета крупный "
                "payload уменьшает число обязательных фрагментов. Поскольку "
                "потеря любого фрагмента делает объект неполным, меньшее "
                "число пакетов обычно повышает шанс полного кадра."
            ),
            (
                "- При фиксированном BER длинный отдельный пакет чаще "
                "повреждается: P(error)=1-(1-BER)^(packet_bits). Одновременно "
                "крупный payload уменьшает число 32-byte headers и общую "
                "длину wire-потока, поэтому итоговый composite success "
                "определяется обоими эффектами."
            ),
            (
                "- Атомарная сборка требует одновременной готовности BASE и "
                "ROI. Даже полностью собранный BASE не даёт полезного "
                "составного кадра без ROI, поэтому composite success ниже "
                "успеха каждого объекта отдельно."
            ),
            (
                "- Burst-loss особенно опасен без интерливинга: соседние "
                "фрагменты и иногда соседние кадры теряются одной серией, "
                "а CRC только обнаруживает ошибку и не восстанавливает "
                "данные."
            ),
            (
                "- Payload 256 B даёт наименьшую длину отдельного пакета и "
                "наименьшую вероятность BER-повреждения одного пакета, но "
                "требует больше всего фрагментов и headers."
            ),
            (
                "- Payload 512 B остаётся умеренным рабочим кандидатом между "
                "packet count и длиной отдельного пакета."
            ),
            (
                "- Payload 1024 B даёт минимум пакетов и header overhead в "
                "этих моделях, но каждый пакет длиннее и при его потере "
                "пропадает более крупный фрагмент JPEG."
            ),
            (
                "- Окончательный packet payload автоматически не выбирается; "
                "для решения нужны Lab029 и последующие данные реального "
                "радиоканала, FEC/ARQ и задержек."
            ),
            "",
            "Артефакты",
            f"- CSV: {CSV_PATH}",
            f"- Independent loss plot: {INDEPENDENT_PLOT_PATH}",
            f"- BER plot: {BER_PLOT_PATH}",
            f"- Burst plot: {BURST_PLOT_PATH}",
            f"- Payload comparison: {PAYLOAD_COMPARISON_PLOT_PATH}",
            (
                "- JPEG, пакеты и бинарные дампы на диск не сохранялись."
            ),
            "",
        ]
    )
    REPORT_PATH.write_text("\n".join(lines), encoding="utf-8")


def validate_results(results: list[SimulationResult]) -> None:
    if len(results) != 45:
        raise RuntimeError(f"expected 45 result rows, got {len(results)}")
    keys = {
        (
            result.model,
            result.parameter_value,
            result.scenario,
            result.payload_size,
        )
        for result in results
    }
    if len(keys) != len(results):
        raise RuntimeError("result rows are not unique")
    for result in results:
        if not 0.0 <= result.packet_delivery_rate <= 1.0:
            raise RuntimeError("packet delivery rate is outside 0...1")
        if not 0.0 <= result.composite_success_rate <= 1.0:
            raise RuntimeError("composite success rate is outside 0...1")
        if (
            result.received_packets + result.lost_packets
            != result.transmitted_packets
        ):
            raise RuntimeError("packet receive/loss accounting disagrees")


def validate_output_files() -> None:
    for path in (
        CSV_PATH,
        REPORT_PATH,
        INDEPENDENT_PLOT_PATH,
        BER_PLOT_PATH,
        BURST_PLOT_PATH,
        PAYLOAD_COMPARISON_PLOT_PATH,
    ):
        if not path.exists() or path.stat().st_size <= 0:
            raise RuntimeError(f"missing or empty output: {path}")


def main() -> None:
    print("Lab029: loading real Lab028 BASE/ROI JPEG profile...")
    metadata, composites = load_video_profile(SOURCE_VIDEO_PATH)
    profiles = prepare_profiles(composites)
    print(
        f"  source={metadata.width}x{metadata.height}, "
        f"frames={metadata.frame_count}, composites={len(composites)}"
    )
    for payload_size in PAYLOAD_SIZES:
        print(
            f"  payload={payload_size}: "
            f"{len(profiles[payload_size].packets)} packets/pass"
        )

    print(
        f"Running 45 Monte Carlo conditions, "
        f"{MONTE_CARLO_REPETITIONS} repetitions each..."
    )
    results = run_monte_carlo(profiles, metadata)
    validate_results(results)

    print("Running Lab029 functional checks...")
    functional_tests = run_functional_tests(
        composites, profiles, metadata, results
    )
    for test in functional_tests:
        print(f"  PASS {test.name}: {test.detail}")

    OUTPUT_DIRECTORY.mkdir(parents=True, exist_ok=True)
    save_csv(results)
    save_plots(results)
    write_report(
        metadata,
        composites,
        profiles,
        results,
        functional_tests,
    )
    validate_output_files()

    print("Representative composite success rates:")
    for payload_size in PAYLOAD_SIZES:
        loss_result = result_lookup(
            results, "independent_loss", 0.01
        )[payload_size]
        ber_result = result_lookup(
            results, "ber", 1e-6
        )[payload_size]
        burst_result = result_lookup(
            results, "burst", scenario="medium"
        )[payload_size]
        print(
            f"  payload={payload_size}: "
            f"loss1%={loss_result.composite_success_rate:.6f}, "
            f"BER1e-6={ber_result.composite_success_rate:.6f}, "
            f"burst-medium={burst_result.composite_success_rate:.6f}"
        )
    print(f"CSV: {CSV_PATH}")
    print(f"Report: {REPORT_PATH}")
    print("Lab029 completed successfully.")


if __name__ == "__main__":
    main()