"""FL-D1/D2 App Block presentation coverage. Not Lane A. Not batch 11."""

from src.domain.app_blocks.canonical import CANONICAL_BLOCK_IDS
from src.domain.app_blocks.job_packs import known_job_pack_ids
from src.domain.app_blocks.presentation_coverage import (
    PRESENTATION_MODES,
    assert_expansion_guards,
    coverage_stats,
    derived_modes,
    load_presentation_coverage,
)
from src.domain.app_blocks.registry import load_default_registry
from src.domain.starter_library.archetypes import known_archetype_ids


def test_fl_d2_covers_every_canonical_block():
    report = load_presentation_coverage()
    assert {item.id for item in report.blocks} == CANONICAL_BLOCK_IDS
    for item in report.blocks:
        assert set(item.modes) == set(PRESENTATION_MODES)


def test_derived_modes_match_authored_slots():
    report = load_presentation_coverage()
    registry = load_default_registry()
    customer = derived_modes(registry.require("crm.customer"))
    assert customer["table"] == "present"
    assert customer["detail"] == "present"
    assert customer["create_edit"] == "present"
    case = derived_modes(registry.require("case.management"))
    assert case["create_edit"] == "present"
    assert case["status_queue"] == "present"
    booking = derived_modes(registry.require("booking.appointment"))
    assert booking["table"] == "present"
    assert booking["create_edit"] == "present"
    assert booking["calendar"] == "present"
    table = derived_modes(registry.require("admin.record_table"))
    assert table["search_filter"] == "present"
    assert table["status_queue"] == "present"
    assert report.block("crm.customer").modes["search_filter"] == "inherited"
    assert report.block("booking.appointment").modes["calendar"] == "present"
    assert report.block("booking.appointment").modes["table"] == "present"
    assert report.block("membership.member").modes["portal_view"] == "held"
    assert report.block("billing.invoice").modes["portal_view"] == "held"
    assert report.block("admin.record_table").modes["status_queue"] == "present"


def test_product_table_coverage_is_complete():
    stats = coverage_stats()
    report = load_presentation_coverage()
    product_blocks = [item for item in report.blocks if item.role == "product"]
    assert stats["product_blocks"] == len(product_blocks)
    assert stats["product_tables_present"] == sum(
        item.modes["table"] == "present" for item in product_blocks
    )
    assert stats["canonical_blocks"] == len(CANONICAL_BLOCK_IDS)
    assert report.block("payments.checkout").role == "product"
    assert report.block("payments.checkout").modes["table"] == "n_a"
    assert report.block("payments.checkout").modes["create_edit"] == "present"
    assert report.block("payments.checkout").modes["portal_view"] == "present"


def test_variants_are_not_new_capabilities_or_blocks():
    report = load_presentation_coverage()
    known = CANONICAL_BLOCK_IDS
    for item in report.d2_queue:
        assert item["block"] in known
        assert item["variant"] not in known
        assert item["status"] == "complete"
    assert all(item.role != "product" or item.id in known for item in report.blocks)


def test_fl_d2_does_not_admit_starters_packs_or_architecture():
    report = load_presentation_coverage()
    assert_expansion_guards(report)
    stats = coverage_stats(report)
    assert stats["starters"] == 11
    assert stats["job_packs"] == len(known_job_pack_ids())
    assert stats["proven_applications"] == 1
    assert stats["declared_applications"] == 25
    assert len(known_archetype_ids()) == 11
    assert len(known_job_pack_ids()) == report.job_pack_count
    assert report.slice == "FL-D2"
    assert report.status == "presentation_variants_complete"


def test_declared_apps_reuse_frozen_ids_and_keep_semantic_guards():
    report = load_presentation_coverage()
    by_id = {item.id: item for item in report.declared_applications}
    assert by_id["board_portal"].forbidden_implicit == ["membership.member", "portal.portal"]
    assert "membership.member" in by_id["committee_ops"].forbidden_implicit
    assert "contract.contract" in by_id["contract_documents"].forbidden_implicit
    assert "payments.checkout" not in by_id["b2b_ordering"].forbidden_implicit
    assert "private_vertical_backend" in by_id["repair_shop"].forbidden_implicit
    assert by_id["salon"].starter == "booking"
    assert by_id["coaching"].starter == "booking"
    assert by_id["clinic_admin"].starter == "booking"
    for app in report.declared_applications:
        if app.id == "student_consultancy":
            assert app.status == "composition_proven_runtime_proven"
        else:
            assert app.status == "declared_not_proven"
        assert "reporting" not in app.packs
        assert "contract.contract" not in app.packs


def test_d3_candidates_are_not_admitted_and_use_frozen_blocks():
    report = load_presentation_coverage()
    admitted = known_job_pack_ids()
    assert len(report.d3_candidate_packs) == 20
    for pack in report.d3_candidate_packs:
        assert pack.id not in admitted
        assert pack.status == "candidate"
        assert pack.starter in known_archetype_ids()
        assert pack.required_app_blocks
        assert all(block_id in CANONICAL_BLOCK_IDS for block_id in pack.required_app_blocks)
        assert "contract.contract" not in pack.required_app_blocks
        assert "portal.portal" not in pack.required_app_blocks


def test_kernel_table_variants_are_the_leverage_path():
    report = load_presentation_coverage()
    queue_blocks = {item["block"] for item in report.d2_queue}
    assert "admin.record_table" in queue_blocks
    assert "booking.appointment" in queue_blocks
    assert "customer-table" not in {item.id for item in report.blocks}
    assert "member-table" not in {item.id for item in report.blocks}