from datetime import datetime, timezone

from satellite_service import MissionCachePackage, SatelliteSyncBoundary
from tile_manager import (
    GeneratedTileSidecar,
    GeneratedTileSyncPackage,
    TileManifestEntry,
)


def _manifest_entry() -> TileManifestEntry:
    return TileManifestEntry(
        tile_id="tile-1",
        chunk_id="chunk-1",
        crs="EPSG:3857",
        meters_per_pixel=0.3,
        capture_date="2026-05-01",
        expires_at=datetime(2026, 6, 1, tzinfo=timezone.utc),
        content_hash="sha256:tile",
        expected_content_hash="sha256:tile",
        sidecar_hash="sha256:sidecar",
        expected_sidecar_hash="sha256:sidecar",
        signature_hash="sig:trusted",
        provenance="suite-satellite-service",
        footprint={"min_lat": 49.0, "max_lat": 49.1},
        descriptor_ref="descriptors/chunk-1.vlad",
    )


def _generated_package() -> GeneratedTileSyncPackage:
    sidecar = GeneratedTileSidecar(
        tile_id="generated-1",
        parent_frame_id="frame-1",
        parent_covariance_m=2.0,
        quality_score=0.8,
        trust_level="generated",
        provenance="nav-camera-generated",
    )
    return GeneratedTileSyncPackage(
        package_ref="generated/mission-1/sync-package.json",
        mission_id="mission-1",
        manifest_delta=({"tile_id": "generated-1", "trust_level": "generated"},),
        sidecars=(sidecar,),
    )


def test_pre_flight_import_returns_package_for_tile_manager_validation() -> None:
    # Arrange
    boundary = SatelliteSyncBoundary()
    package = MissionCachePackage(
        package_id="pkg-1",
        mission_id="mission-1",
        manifest_entries=(_manifest_entry(),),
    )

    # Act
    result = boundary.import_mission_cache(package, phase="pre_flight")

    # Assert
    assert result.ready_for_tile_validation is True
    assert result.manifest_entries[0].tile_id == "tile-1"
    assert boundary.status().imported_package_ids == ("pkg-1",)


def test_post_flight_upload_records_retryable_failure_for_audit() -> None:
    # Arrange
    boundary = SatelliteSyncBoundary(uploader=lambda package: "retryable_failure")

    # Act
    result = boundary.upload_generated_tiles(_generated_package(), phase="post_flight")

    # Assert
    assert result.upload_record is not None
    assert result.upload_record.status == "retryable_failure"
    assert result.upload_record.retained_for_retry is True
    assert boundary.status().retry_package_refs == ("generated/mission-1/sync-package.json",)


def test_in_flight_sync_is_blocked_without_calling_network_boundary() -> None:
    # Arrange
    calls: list[str] = []

    def uploader(package: GeneratedTileSyncPackage) -> str:
        calls.append(package.package_ref)
        return "success"

    boundary = SatelliteSyncBoundary(uploader=uploader)

    # Act
    result = boundary.upload_generated_tiles(_generated_package(), phase="in_flight")

    # Assert
    assert result.upload_record is None
    assert result.error is not None
    assert result.error.cause == "mid_flight_network_blocked"
    assert calls == []