"""Read-only Australian Capital Territory shadow-pilot orchestration."""

from __future__ import annotations

from dataclasses import dataclass
from pathlib import Path

from ..domain.models import ProfileVersion
from ..normalization.models import NormalizationContext
from ..profiles import ProfileEvaluator, builtin_profile_registry
from ..shadow import ShadowSourceReport, run_profile_shadow
from .geofabrik import AU_ACT_PILOT, AcquiredPbf, acquire_region
from .models import PbfParseLimits, VerifiedPbfInput
from .parser import OsmiumPbfParser

_PILOT_PROFILE = ProfileVersion("luxeillum", "0.1.0-draft")


@dataclass(frozen=True, slots=True)
class ActShadowPilotResult:
    """Acquisition evidence and deterministic source-shadow report."""

    acquisition: AcquiredPbf
    report: ShadowSourceReport

    def evidence_mapping(self) -> dict[str, object]:
        return {
            "acquisition": self.acquisition.as_mapping(),
            "lead_count": len(self.report.leads),
            "mode": "shadow-read-only",
            "noco_access": False,
            "profile": {
                "id": self.report.profile.profile_id,
                "version": self.report.profile.version,
            },
            "region": AU_ACT_PILOT.as_mapping(),
            "report_hash": self.report.report_hash,
            "review_count": len(self.report.review_items),
            "scheduler_enabled": False,
            "writes_enabled": False,
        }


def run_act_shadow_pilot(
    cache_dir: Path,
    *,
    timeout_seconds: float = 120.0,
    max_leads: int = 100_000,
    max_review_items: int = 100_000,
) -> ActShadowPilotResult:
    """Acquire, parse, and profile ACT without reading or writing NocoDB."""

    acquisition = acquire_region(
        AU_ACT_PILOT,
        cache_dir,
        timeout_seconds=timeout_seconds,
    )
    registry = builtin_profile_registry()
    definition = registry.get(_PILOT_PROFILE)
    limits = PbfParseLimits(
        max_file_size_bytes=AU_ACT_PILOT.max_size_bytes,
        max_objects=5_000_000,
        max_total_tags=25_000_000,
        max_tags_per_object=512,
        max_blob_size_bytes=32 * 1024 * 1024,
        max_uncompressed_blob_bytes=32 * 1024 * 1024,
        max_total_uncompressed_bytes=2 * 1024 * 1024 * 1024,
        max_blob_count=50_000,
    )
    report = run_profile_shadow(
        approved_input=VerifiedPbfInput(
            local_path=acquisition.local_path,
            content_sha256=acquisition.content_sha256,
            size_bytes=acquisition.size_bytes,
            provenance="checksum-verified Geofabrik ACT shadow pilot",
        ),
        parser=OsmiumPbfParser(limits),
        evaluator=ProfileEvaluator(registry),
        definition=definition,
        region_id=AU_ACT_PILOT.region_id,
        normalization_context=NormalizationContext(
            country_code=AU_ACT_PILOT.country_code,
            calling_code=AU_ACT_PILOT.calling_code,
        ),
        max_leads=max_leads,
        max_review_items=max_review_items,
        verify_unique_objects=False,
    )
    return ActShadowPilotResult(acquisition, report)


__all__ = ["ActShadowPilotResult", "run_act_shadow_pilot"]