"""Helpers for GUI-side runtime history management."""

from __future__ import annotations

from collections import deque
from typing import TypeVar

from python_app.models.dataset_model import ResultCollection, SweepCollection
from python_app.models.run_config_model import RunConfigModel
from python_app.orchestration.preprocess_assets import PREPROCESS_ASSET_KEYS, preprocess_asset_model

THistoryCollection = TypeVar("THistoryCollection", SweepCollection, ResultCollection)


def record_result_history(
    result_history: deque[ResultCollection],
    collection: ResultCollection,
) -> None:
    """Append a new result, or replace the existing entry with the same stable key."""
    for index in range(len(result_history) - 1, -1, -1):
        existing = result_history[index]
        if (
            existing.collection_id == collection.collection_id
            and existing.monotonic_ns == collection.monotonic_ns
        ):
            result_history[index] = collection
            return

    result_history.append(collection)


def remove_last_aligned_histories(
    raw_history: list[SweepCollection],
    preprocessed_history: list[SweepCollection],
    result_history: list[ResultCollection],
) -> tuple[list[SweepCollection], list[SweepCollection], list[ResultCollection]]:
    """Remove the newest aligned history entry using results as preferred anchor."""
    retained_raw = list(raw_history)
    retained_preprocessed = list(preprocessed_history)
    retained_results = list(result_history)

    if retained_results:
        target_key = _tail_occurrence_key(retained_results, len(retained_results) - 1)
        retained_results.pop()
        _remove_by_tail_occurrence_key(retained_raw, target_key)
        _remove_by_tail_occurrence_key(retained_preprocessed, target_key)
        return retained_raw, retained_preprocessed, retained_results

    if retained_preprocessed:
        target_key = _tail_occurrence_key(retained_preprocessed, len(retained_preprocessed) - 1)
        retained_preprocessed.pop()
        _remove_by_tail_occurrence_key(retained_raw, target_key)
        return retained_raw, retained_preprocessed, retained_results

    if retained_raw:
        retained_raw.pop()

    return retained_raw, retained_preprocessed, retained_results


def build_processor_run_signature(
    config: RunConfigModel,
) -> tuple[object, ...]:
    """Build signature of settings that change the data SHAPE the data_processor parses.

    Excludes the preprocess set names on purpose: the data_processor does not consume
    calibration/reference sets (those are applied upstream by the data_preprocessor), so
    changing a set must NOT restart the processor. Restarting it would also tear down the
    locator TCP server it hosts and drop every connected client. Only genuine shape changes
    (radar model, sweep, switch layout, combos) require a processor restart.
    """
    combos_signature = tuple((int(combo.input), int(combo.output)) for combo in config.combos)
    sweep_points_signature: object = "adc" if config.is_kamil_adc else int(config.radar.sweep.points)
    return (
        str(config.radar.model),
        str(config.radar.driver_mode),
        str(config.radar.serial),
        tuple(str(value) for value in config.radar.multi_device.slave_serials),
        bool(config.radar.multi_device.force_external_reference),
        float(config.radar.sweep.start_hz),
        float(config.radar.sweep.stop_hz),
        sweep_points_signature,
        float(config.radar.sweep.if_bandwidth_hz),
        float(config.radar.sweep.power_dbm),
        str(config.input_switch.driver_mode),
        str(config.input_switch.driver),
        int(config.input_switch.positions),
        bool(config.input_switch.invert_logic),
        str(config.output_switch.driver_mode),
        str(config.output_switch.driver),
        int(config.output_switch.positions),
        bool(config.output_switch.invert_logic),
        combos_signature,
    )


def build_run_history_signature(
    config: RunConfigModel,
) -> tuple[object, ...]:
    """Build full signature for GUI display-history reset (processor shape + preprocess sets).

    Display history still resets when the reference/calibration set changes (the on-screen
    B-scan would otherwise mix old- and new-reference frames), even though the processor
    process itself is intentionally kept alive across that change.
    """
    preprocess_signature = tuple(preprocess_asset_model(config, key).set_name for key in PREPROCESS_ASSET_KEYS)
    return build_processor_run_signature(config) + (preprocess_signature,)


def _tail_occurrence_key(history: list[THistoryCollection], index: int) -> tuple[int, int]:
    """Return `(collection_id, occurrence_from_tail)` for the item at `index`."""
    collection_id = int(history[index].collection_id)
    occurrence_from_tail = 0
    for cursor in range(len(history) - 1, index, -1):
        if int(history[cursor].collection_id) == collection_id:
            occurrence_from_tail += 1
    return collection_id, occurrence_from_tail


def _remove_by_tail_occurrence_key(history: list[THistoryCollection], key: tuple[int, int]) -> bool:
    """Remove newest matching entry identified by `(collection_id, occurrence_from_tail)`."""
    collection_id, target_occurrence = key
    occurrence_from_tail = 0
    for index in range(len(history) - 1, -1, -1):
        if int(history[index].collection_id) != collection_id:
            continue
        if occurrence_from_tail == target_occurrence:
            history.pop(index)
            return True
        occurrence_from_tail += 1
    return False