"""Phase 2D — private Core document invoke HTTP. Catalog invocable stays false."""
from __future__ import annotations

from uuid import uuid4

from src.domain.codegen.prompt_wrapper import _app_recipes
from src.domain.connectors.document_resolve import (
    DocumentConnectionSnapshot,
    normalize_google_document,
    resolve_document,
    to_public_document_result,
)
from src.domain.connectors.invoke_capabilities import (
    DOCUMENT_CREATE_POST_CREATE_BINDING,
    DOCUMENT_FAMILY_PHASE_2D,
    DOCUMENT_FAMILY_RESOLVER_DESIGN,
    DOCUMENT_FROZEN_VERBS,
    DOCUMENT_OUTPUT_SCHEMA,
    is_implemented,
)
from src.domain.connectors.public_gateway import (
    PHASE_2D_STATUS,
    PHASE_2E_STATUS,
    PUBLIC_INVOCABLE_CAPABILITIES,
    strip_capability_response,
)
from src.domain.connectors.router import capability_router
from src.domain.manifest.service import _connectors_manifest_envelope
from src.main import app

_CAPS = {"integrations.execute"}
_GOOGLE_ID = "1aBcDeFgHiJkLmNoPqRsTuVwXyZ0123456789abc"


def _docs(**overrides) -> DocumentConnectionSnapshot:
    data = dict(
        connection_id=uuid4(),
        connector_key="google_docs",
        status="active",
        has_secrets=True,
        permission_mode="allow",
        config={"document": "proposal", "document_id": _GOOGLE_ID},
        requires_secrets=True,
        client_side_only=False,
    )
    data.update(overrides)
    return DocumentConnectionSnapshot(**data)


def test_phase_2d_is_private_core_http_without_catalog_flips() -> None:
    assert PHASE_2D_STATUS == "complete"
    assert PHASE_2E_STATUS == "complete"
    phase = DOCUMENT_FAMILY_PHASE_2D
    assert phase["core_private_invoke_http"] is True
    assert phase["catalog_invocable"] is False
    assert phase["implements_attached"] is False
    assert phase["public_bff_capability_route"] is False
    assert phase["document_ref_emitted"] is False
    assert phase["next_slice"] == "2f_document_runtime_truth"
    assert DOCUMENT_FAMILY_RESOLVER_DESIGN["core_private_invoke_http"] is True
    assert DOCUMENT_CREATE_POST_CREATE_BINDING["blocks_2c"] is False
    assert "document_ref" not in DOCUMENT_OUTPUT_SCHEMA["properties"]
    envelope = _connectors_manifest_envelope(items={})
    for verb in DOCUMENT_FROZEN_VERBS:
        cap = envelope["capabilities"][verb]
        assert cap["method"] is not None
        assert is_implemented(verb) is True
        assert verb in PUBLIC_INVOCABLE_CAPABILITIES
    assert "capabilities/document." in _app_recipes()


def test_core_registers_private_document_capability_routes() -> None:
    paths = {
        getattr(route, "path", "")
        for route in capability_router.routes
    }
    for verb in DOCUMENT_FROZEN_VERBS:
        assert f"/api/projects/{{project_id}}/capabilities/{verb}" in paths
    app_paths = {getattr(route, "path", "") for route in app.routes}
    for verb in DOCUMENT_FROZEN_VERBS:
        assert f"/api/projects/{{project_id}}/capabilities/{verb}" in app_paths


def test_enqueue_without_result_is_queued_not_document_ref() -> None:
    resolution = resolve_document(
        capability="document.append_text",
        payload={"document": "proposal", "text": "more"},
        connections=[_docs()],
        enabled_capabilities=_CAPS,
        enforce_invocable=False,
    )
    public = to_public_document_result(
        resolution,
        capability="document.append_text",
        enqueue={"ok": True, "job_id": "job_1", "status": "queued"},
    ).as_dict()
    assert public == {
        "capability": "document.append_text",
        "status": "queued",
    }
    stripped = strip_capability_response({**public, "document_id": _GOOGLE_ID, "action": "x"})
    assert stripped == public


def test_create_does_not_emit_document_ref_from_google_id() -> None:
    resolution = resolve_document(
        capability="document.create",
        payload={"title": "Proposal"},
        connections=[_docs(config={})],
        enabled_capabilities=_CAPS,
        enforce_invocable=False,
    )
    public = to_public_document_result(
        resolution,
        capability="document.create",
        enqueue={
            "ok": True,
            "output": {"documentId": _GOOGLE_ID, "document_id": _GOOGLE_ID, "title": "Proposal"},
        },
    ).as_dict()
    assert public == {"capability": "document.create", "status": "succeeded"}
    assert "document_ref" not in public
    assert _GOOGLE_ID not in str(public)


def test_get_succeeded_normalizes_document_without_google_ids() -> None:
    raw = {
        "documentId": _GOOGLE_ID,
        "revisionId": "rev-9",
        "title": "Proposal",
        "body": {
            "content": [
                {
                    "paragraph": {
                        "elements": [{"textRun": {"content": "Hello\n"}}],
                    }
                }
            ]
        },
    }
    normalized = normalize_google_document(raw)
    assert normalized == {"title": "Proposal", "body_text": "Hello\n"}
    assert "documentId" not in normalized
    resolution = resolve_document(
        capability="document.get",
        payload={"document": "proposal"},
        connections=[_docs()],
        enabled_capabilities=_CAPS,
        enforce_invocable=False,
    )
    public = to_public_document_result(
        resolution,
        capability="document.get",
        enqueue={"ok": True, "output": raw},
    ).as_dict()
    assert public == {
        "capability": "document.get",
        "status": "succeeded",
        "document": {"title": "Proposal", "body_text": "Hello\n"},
    }
    assert _GOOGLE_ID not in str(public)
    assert "revisionId" not in str(public)