"""Event-driven continuation engine for the corrective 0.4 rebuild."""
from __future__ import annotations

import hashlib
from dataclasses import dataclass
from typing import Any, Mapping

from tom_world03.canonical import attach_hash, canonical_bytes

from .model import ContinuationWorld, OpenSegment, qmap_record
from .solver import next_event_set
from .transition import EventBundle, FinalizationBundle, apply_event_set, finalize_segment


@dataclass(frozen=True, slots=True)
class ContinuationRun:
    record: Mapping[str, Any]
    open_segments: tuple[OpenSegment, ...]
    bundles: tuple[EventBundle, ...]
    finalization: FinalizationBundle


def _semantic_chain(
    world: ContinuationWorld,
    open_segments: list[OpenSegment],
    bundles: list[EventBundle],
    finalization: FinalizationBundle,
) -> dict[str, Any]:
    realized_segments: list[dict[str, Any]] = []
    for segment, bundle in zip(open_segments, bundles):
        realized_segments.append({
            "sequence": segment.sequence,
            "domain": bundle.seal["realized_domain"],
            "start_state": qmap_record(segment.start_state),
            "rates": qmap_record(segment.rates),
            "end_state": bundle.seal["end_state"],
        })
    final_segment = open_segments[-1]
    realized_segments.append({
        "sequence": final_segment.sequence,
        "domain": finalization.seal["realized_domain"],
        "start_state": qmap_record(final_segment.start_state),
        "rates": qmap_record(final_segment.rates),
        "end_state": finalization.seal["end_state"],
    })

    event_sets = [
        {
            "event_time": bundle.event_set["event_time"],
            "event_order": list(bundle.event_set["event_order"]),
            "relation_order": list(bundle.event_set["relation_order"]),
            "pre_state": bundle.transition["pre_state"],
            "post_state": bundle.transition["post_state"],
            "pre_rates": bundle.transition["pre_rates"],
            "post_rates": bundle.transition["post_rates"],
            "fired_relations_after": list(bundle.successor.fired_relations),
        }
        for bundle in bundles
    ]
    return {
        "schema": "TOM-CONTINUATION-SEMANTIC-CHAIN-0.4.1",
        "world_hash": world.content_hash,
        "corrected_v03_zip_sha256": world.corrected_v03_zip_sha256,
        "corrected_interval_sha256": world.corrected_interval_sha256,
        "realized_segments": realized_segments,
        "event_sets": event_sets,
        "final_time": world.horizon.upper.to_record(),
        "final_state": finalization.transaction["final_state"],
        "fired_relations": list(final_segment.fired_relations),
        "boundary_policy": "event times are solver outputs; final boundary is the declared world horizon",
    }


def run_continuation(
    world: ContinuationWorld,
    *,
    planner: str = "indexed",
    max_event_sets: int | None = None,
    store: Any | None = None,
) -> ContinuationRun:
    max_sets = int(world.solver.get("max_event_sets", 64) if max_event_sets is None else max_event_sets)
    profile_max = int(world.solver.get("profile_max_event_sets", 1024))
    if max_sets < 0 or max_sets > profile_max:
        raise ValueError(f"max_event_sets {max_sets} outside 0..{profile_max}")

    current = world.initial_segment
    open_segments: list[OpenSegment] = [current]
    bundles: list[EventBundle] = []
    query_certificates: list[Mapping[str, Any]] = []
    while True:
        event_set = next_event_set(world, current, planner=planner)
        query_certificates.append(event_set)
        if event_set["status"] == "none":
            finalization = finalize_segment(world, current)
            if store is not None:
                store.commit_finalization(finalization)
            break
        if len(bundles) >= max_sets:
            raise ValueError("event-set budget exhausted before world horizon")
        bundle = apply_event_set(world, current, event_set)
        if store is not None:
            store.commit_event(bundle)
        bundles.append(bundle)
        current = bundle.successor
        open_segments.append(current)

    semantic = _semantic_chain(world, open_segments, bundles, finalization)
    semantic_hash = "sha256:" + hashlib.sha256(canonical_bytes(semantic)).hexdigest()
    record = attach_hash({
        "schema": "TOM-CONTINUATION-RUN-0.4.1",
        "world_hash": world.content_hash,
        "planner": planner,
        "status": "complete",
        "stop_reason": "no-later-event-and-horizon-sealed",
        "event_set_count": len(bundles),
        "realized_segment_count": len(open_segments),
        "open_segment_hashes": [segment.content_hash for segment in open_segments],
        "event_set_hashes": [bundle.event_set["content_hash"] for bundle in bundles],
        "transition_hashes": [bundle.transition["content_hash"] for bundle in bundles],
        "seal_hashes": [bundle.seal["content_hash"] for bundle in bundles] + [finalization.seal["content_hash"]],
        "transaction_hashes": [bundle.transaction["content_hash"] for bundle in bundles] + [finalization.transaction["content_hash"]],
        "query_certificate_hashes": [record["content_hash"] for record in query_certificates],
        "total_scanned_brackets": sum(int(record["scanned_brackets"]) for record in query_certificates),
        "total_candidate_relations": sum(int(record["total_candidate_relations"]) for record in query_certificates),
        "semantic_chain": semantic,
        "semantic_chain_sha256": semantic_hash,
        "journal_head": None if store is None else store.head,
    })
    return ContinuationRun(record, tuple(open_segments), tuple(bundles), finalization)