"""Enqueue Core-resolved payments.* jobs onto the existing payment.* Cloud types."""
from __future__ import annotations

from typing import Any
from uuid import UUID

from src.domain.cloud.schemas import (
    AuthorizeRequest,
    AuthorizeRequestMeta,
    AuthorizeResponseDenied,
)
from src.domain.cloud.service import CloudInternalService, _expected_client_id
from src.domain.connectors.idempotency import execute_idempotency_key
from src.domain.connectors.payment_resolve import job_type_for_payment_capability
from src.integrations.cloud_control_client import CloudControlClient


async def enqueue_authorized_payment_job(
    *,
    cloud_svc: CloudInternalService,
    cloud_client: CloudControlClient,
    project: Any,
    workspace_id: UUID,
    capability: str,
    payload: dict[str, Any],
    idempotency_key: str | None = None,
    handshake_id: str = "core_capability_invoke",
    provider_hint: str | None = None,
    connection_id: str | None = None,
) -> dict[str, Any]:
    job_type = job_type_for_payment_capability(capability)
    idem = execute_idempotency_key(idempotency_key)
    auth = await cloud_svc.authorize(
        AuthorizeRequest(
            workspace_id=str(workspace_id),
            project_id=str(project.id),
            client_id=_expected_client_id(project),
            handshake_id=handshake_id,
            request_type=job_type,
            idempotency_key=idem,
            connection_id=connection_id,
            request_meta=AuthorizeRequestMeta(
                origin="",
                payload_hash="",
                estimated_units=1,
                provider_hint=provider_hint,
            ),
        )
    )
    if isinstance(auth, AuthorizeResponseDenied):
        return {
            "ok": False,
            "reason_code": auth.reason_code or "capability_not_bound",
            "message": auth.message or auth.reason_code,
        }

    result = await cloud_client.enqueue_control_job(
        project_id=str(project.id),
        workspace_id=str(workspace_id),
        client_id=_expected_client_id(project),
        request_type=job_type,
        idempotency_key=idem,
        payload={
            **payload,
            **(
                {"connection_id": auth.policy_snapshot.connection_id}
                if auth.policy_snapshot.connection_id
                else {}
            ),
        },
        authorization_id=auth.authorization_id,
        grant_jwt=auth.grant.jwt,
        grant_expires_at=auth.grant.expires_at,
        policy_snapshot=auth.policy_snapshot.model_dump(mode="json"),
    )
    if not result.get("ok"):
        cloud_error = result.get("error") or "cloud_enqueue_failed"
        return {
            "ok": False,
            "reason_code": "provider_unavailable",
            "message": f"Failed to queue {job_type} job: {cloud_error}",
        }
    return {
        "ok": True,
        "job_id": str(result.get("job_id") or ""),
        "status": str(result.get("status") or "queued"),
        "capability": capability,
    }