"""Application service façade for scoped persistence operations."""

from __future__ import annotations

from uuid import UUID

from sqlalchemy.orm import Session

from packages.hub_core.domain import Approval, AuditEvent, Connector, Operation, ReconcileRun, Scope

from .repositories import (
    ApprovalRepository,
    AuditEventRepository,
    ConnectorRepository,
    OperationRepository,
    ReconcileRunRepository,
)


class ControlPlanePersistenceService:
    """Explicit service boundary used by future API/worker adapters."""

    def __init__(self, session: Session, scope: Scope) -> None:
        self.session = session
        self.scope = scope

    def transition_connector_health(
        self, connector_id: UUID, target: str, *, expected_version: int
    ) -> Connector:
        return ConnectorRepository(self.session, self.scope).transition_health(
            connector_id, target, expected_version=expected_version
        )

    def transition_reconcile_run(
        self, run_id: UUID, target: str, *, expected_version: int
    ) -> ReconcileRun:
        return ReconcileRunRepository(self.session, self.scope).transition_status(
            run_id, target, expected_version=expected_version
        )

    def transition_operation(
        self, operation_id: UUID, target: str, *, expected_version: int
    ) -> Operation:
        return OperationRepository(self.session, self.scope).transition_state(
            operation_id, target, expected_version=expected_version
        )

    def transition_approval(
        self, approval_id: UUID, target: str, *, expected_version: int
    ) -> Approval:
        return ApprovalRepository(self.session, self.scope).transition_state(
            approval_id, target, expected_version=expected_version
        )

    def record_audit(self, event: AuditEvent) -> AuditEvent:
        return AuditEventRepository(self.session, self.scope).create(event)