"""Doc scenario Test A -- no invented backend.

Given: project needs persisted application data; P2HS Cloud is available; no custom
backend has ever been approved.
Expect: the Cloud binding is selected, the generated implementation calls Cloud (never a
local store) -- and if something ever DID slip a local backend in, the guard rejects it.

Chains the real functions this effort built (extract_runtime_invariants -> a
ProjectRuntimeContract-shaped dict -> contact_adapter_files/app_sdk_files ->
validate_backend_repo) instead of re-mocking any of them with a hand-built fixture.
"""
from __future__ import annotations

import tempfile
from pathlib import Path

import pytest

from src.domain.codegen.app_sdk import app_sdk_files
from src.domain.codegen.backend_guard import validate_backend_repo
from src.domain.codegen.contact_adapter import contact_adapter_files
from src.domain.projects.runtime_invariants import ProjectRuntimeInvariants, extract_runtime_invariants


def _contract_dict(invariants: ProjectRuntimeInvariants) -> dict:
    """Same shape resolve_runtime_contract produces (runtime_contract.py) -- built
    here from the real extractor's output instead of a fixture invented by this test."""
    return {
        "contract_version": 1,
        "runtime": {"backend": "p2hs-cloud", "allow_custom_backend": invariants.allow_custom_backend},
        "routes": {
            "admin_panel_path": invariants.admin_panel_path,
            "customer_login_path": invariants.customer_login_path,
        },
        "capabilities": {
            "data": {"provider": "p2hs-cloud", "available": True},
            "auth": {"provider": "p2hs-auth", "magic_link": "magic_link" in invariants.auth_modes},
            "email": {"provider": None, "binding": None, "available": False},
        },
        "constraints": {"must": [], "must_not": []},
    }


@pytest.mark.parametrize("project_type", ["html", "react_app", "nuxt_app"])
def test_persistence_request_resolves_to_cloud_never_a_local_store(project_type):
    invariants = extract_runtime_invariants(
        "Create a contact form and let the admin view submissions.",
        ProjectRuntimeInvariants(),
    )
    assert invariants.persistence_required is True

    contract = _contract_dict(invariants)
    assert contract["runtime"]["allow_custom_backend"] is False
    assert contract["capabilities"]["data"]["provider"] == "p2hs-cloud"

    files = {
        **contact_adapter_files(project_type, runtime_contract=contract),
        **app_sdk_files(project_type, runtime_contract=contract),
    }
    server_side = {
        name: content
        for name, content in files.items()
        if "p2hs-contact" in name or name.endswith("contact.post.ts") or "contact-pages-fn" in name
    }
    assert server_side, "expected at least one contact BFF file"
    for name, content in server_side.items():
        if "p2hs-contact" not in name:
            continue
        assert "readCloudConfig" in content or "cloudGatewayUrl" in content, name
        for marker in ("useStorage(", "better-sqlite3", "lowdb", "new Map()"):
            assert marker not in content, f"{name} contains a local-store marker: {marker}"


def test_guard_rejects_an_invented_backend_when_it_slips_in():
    """The enforcement half: if a run ever DID invent a local backend despite the
    resolved contract saying Cloud, validate_backend_repo must catch it."""
    with tempfile.TemporaryDirectory() as raw:
        root = Path(raw)
        path = root / "server" / "api" / "contact.post.ts"
        path.parent.mkdir(parents=True)
        path.write_text(
            "const submissions = useStorage('db:submissions');\n"
            "export default defineEventHandler(async (event) => {\n"
            "  await submissions.setItem(Date.now().toString(), await readBody(event));\n"
            "});\n",
            encoding="utf-8",
        )
        with pytest.raises(ValueError):
            validate_backend_repo(raw)