"""Four runtime surfaces are explicit and non-overlapping."""
from src.domain.connectors.catalog import slugs_implementing
from src.domain.connectors.invoke_capabilities import (
    INVOKE_CAPABILITIES,
    catalog_consistency_issues,
)
from src.domain.connectors.runtime_surfaces import (
    INVOKE_BOUNDARIES,
    PAYMENT_INVOKE_VERBS,
    PUBLIC_STUB_REQUEST_TYPES,
    STORAGE_FILE_SCOPE,
    catalog_invariants,
    composition_ids,
    invoke_capability_ids,
    native_port_ids,
    surface_of,
)
from src.integrations.platform_ports import QUEUE_REQUEST_TYPES


def test_surfaces_do_not_overlap():
    invoke = invoke_capability_ids()
    native = native_port_ids()
    composition = composition_ids()
    assert not (invoke & native)
    assert not (invoke & composition)
    assert not (native & composition)


def test_invoke_catalog_is_provider_resolution_only():
    for cap_id in invoke_capability_ids():
        assert INVOKE_BOUNDARIES[cap_id] in {"B", "C"}
        assert INVOKE_BOUNDARIES[cap_id] != "A"
        assert surface_of(cap_id) == "invoke"


def test_payments_are_invoke_not_native_primitives():
    for cap_id in PAYMENT_INVOKE_VERBS:
        assert cap_id in INVOKE_CAPABILITIES
        assert INVOKE_BOUNDARIES[cap_id] == "C"
        assert surface_of(cap_id) == "invoke"
        assert cap_id not in native_port_ids()
    assert slugs_implementing("payments.checkout.create")
    assert "stripe.create_checkout" in slugs_implementing("payments.checkout.create")
    assert "paypal.create_order" in slugs_implementing("payments.checkout.create")
    assert "stripe.create_product" in slugs_implementing("payments.catalog.upsert")


def test_storage_file_is_customer_connector_class_c():
    assert STORAGE_FILE_SCOPE["storage_scope"] == "customer_connector"
    assert STORAGE_FILE_SCOPE["platform_fallback"] is False
    assert INVOKE_BOUNDARIES["storage.file.put"] == "C"
    surface = INVOKE_CAPABILITIES["storage.file.put"]
    assert surface["id"] == "storage.file.put"


def test_native_booking_is_not_an_invoke_verb():
    assert surface_of("booking.reserve") == "native"
    assert "booking.reserve" not in INVOKE_CAPABILITIES


def test_pack_provides_are_composition():
    assert surface_of("payments.checkout") == "composition"
    assert "payments.checkout" not in INVOKE_CAPABILITIES


def test_stubs_are_absent_from_public_runtime():
    for stub in PUBLIC_STUB_REQUEST_TYPES:
        assert stub not in QUEUE_REQUEST_TYPES
        assert stub not in INVOKE_CAPABILITIES
    assert "pdf.generate" not in QUEUE_REQUEST_TYPES
    assert "custom.provider.request" not in QUEUE_REQUEST_TYPES
    assert "notification.sms" not in INVOKE_CAPABILITIES
    assert "messaging.sms.send" in INVOKE_CAPABILITIES
    assert INVOKE_CAPABILITIES["messaging.sms.send"]["invocable"] is True
    assert "twilio.send_sms" in slugs_implementing("messaging.sms.send")


def test_catalog_invariants_hold():
    assert catalog_invariants() == ()
    assert catalog_consistency_issues() == ()


def test_dash_bff_allowlist_matches_public_invoke():
    import re
    from pathlib import Path

    from src.domain.connectors.public_gateway import PUBLIC_BFF_PROXY_CAPABILITIES

    path = (
        Path(__file__).resolve().parents[2]
        / "P2HS-Dash"
        / "server"
        / "api"
        / "projects"
        / "[projectId]"
        / "capabilities"
        / "[capability].post.ts"
    )
    if not path.exists():
        return
    source = path.read_text(encoding="utf-8")
    block = re.search(r"const PUBLIC_BFF_PROXY = new Set\(\[(.*?)\]\)", source, re.S)[1]
    dash = set(re.findall(r"'([^']+)'", block))
    assert dash == set(PUBLIC_BFF_PROXY_CAPABILITIES)
    assert PAYMENT_INVOKE_VERBS <= dash