"""Deterministic structured WHY evidence; no generative or advisory prose."""

from __future__ import annotations

from mountain_twin.rci.contracts import (
    ConditionSignal,
    RouteConditionCluster,
    RouteConditionEvent,
    StructuredWhy,
)


def signal_why(signal: ConditionSignal) -> StructuredWhy:
    return StructuredWhy(
        what={"definition_id": signal.definition_id, "category": signal.category},
        where={
            "start_route_index": signal.start_route_index,
            "end_route_index": signal.end_route_index,
            "start_route_distance_m": signal.start_route_distance_m,
            "end_route_distance_m": signal.end_route_distance_m,
        },
        when={
            "start_planned_time": signal.start_planned_time,
            "end_planned_time": signal.end_planned_time,
            "active_duration_s": signal.active_duration_s,
            "total_duration_s": signal.total_duration_s,
        },
        input_values=signal.relevant_values,
        rule={
            "applied_rule": signal.applied_rule,
            "threshold_provenance": tuple(item.to_dict() for item in signal.threshold_provenance),
        },
        result={
            "qualified": True,
            "active_distance_m": signal.active_distance_m,
            "total_distance_m": signal.total_distance_m,
            "bridged_false_gap_count": len(signal.bridged_false_gaps),
        },
        source=signal.evidence_payload,
        quality=signal.quality.to_dict() if signal.quality is not None else {},
        boundaries=signal.boundaries,
    )


def cluster_why(cluster: RouteConditionCluster) -> StructuredWhy:
    return StructuredWhy(
        what={"definition_ids": cluster.definition_ids, "signal_instance_ids": cluster.signal_instance_ids},
        where={
            "start_route_index": cluster.start_route_index,
            "end_route_index": cluster.end_route_index,
            "start_route_distance_m": cluster.start_route_distance_m,
            "end_route_distance_m": cluster.end_route_distance_m,
        },
        when={"start_planned_time": cluster.start_planned_time, "end_planned_time": cluster.end_planned_time},
        input_values={},
        rule={"overlap_axis": cluster.overlap_axis, "minimum_distinct_definitions": 2},
        result={"simultaneously_active_signal_count": len(cluster.signal_instance_ids)},
        source=cluster.evidence_payload,
        quality=cluster.quality.to_dict() if cluster.quality is not None else {},
    )


def event_why(event: RouteConditionEvent) -> StructuredWhy:
    return StructuredWhy(
        what={"event_type": event.event_type},
        where={"route_point_index": event.route_point_index, "route_distance_m": event.route_distance_m},
        when={"planned_time": event.planned_time},
        input_values={"value": event.value, "unit": event.unit},
        rule={"event_semantics": event.event_type},
        result=event.evidence_payload,
        source={"source_reference": event.source_reference},
        quality=event.quality.to_dict() if event.quality is not None else {},
    )