from scripts.verify_backend_bundle_readiness import build_readiness


def test_backend_readiness_covers_every_marketing_page_and_bundle():
    report = build_readiness()
    assert report["page_count"] == 205
    assert report["bundle_count"] == 42
    assert len(report["page_register"]) == 205
    assert len({item["slug"] for item in report["page_register"]}) == 205
    assert sum(item["page_count"] for item in report["bundles"]) == 205
    assert all(not item["missing_blocks"] for item in report["bundles"])
    assert all(not item["pack_errors"] for item in report["bundles"])
    assert all(not item["missing_starters"] for item in report["bundles"])
    assert all(
        item["platform_readiness"] in {"native", "external_capability_required"}
        for item in report["bundles"]
    )
    assert all(
        item["external_requirement"]
        in {
            "none",
            "credential_configuration",
            "external_provider_required",
            "external_system_dependency",
            "unimplemented_external_semantics",
        }
        for item in report["bundles"]
    )


def test_backend_readiness_keeps_specialist_and_integration_gaps_explicit():
    report = build_readiness()
    all_platform_gaps = {
        gap for bundle in report["bundles"] for gap in bundle["platform_gaps"]
    }
    all_configuration_gaps = {
        gap for bundle in report["bundles"] for gap in bundle["configuration_gaps"]
    }
    assert "subscription_billing" not in all_platform_gaps
    assert "lms_runtime" not in all_platform_gaps
    assert "stripe_subscription" in all_configuration_gaps


def test_backend_readiness_classifies_every_open_gap():
    report = build_readiness()
    register = {item["token"]: item for item in report["gap_register"]}
    assert register == {}
    assert all(item["category"] != "review_required" for item in register.values())
    assert "lms_runtime" not in register
    assert "manufacturing_mrp" not in register
    assert "finite_capacity_scheduling" not in register
    assert "payments.checkout" not in register


def test_backend_page_register_carries_composition_and_gap_ownership():
    report = build_readiness()
    rows = {item["slug"]: item for item in report["page_register"]}

    row = rows["membership-management-system"]
    assert row["bundle_id"] in {item["bundle_id"] for item in report["bundles"]}
    assert "membership-management" in row["feature_packs"]
    assert "data.entity" in row["primitive_ids"]
    assert "automatic_renewal" not in row["gap_categories"]
    assert "saas-membership" in row["feature_packs"]
    assert row["status"] == "configuration_required"
    assert "entitlements" not in row["gap_categories"]
    assert "member_portal" not in row["gap_categories"]

    gym = rows["gym-management-software"]
    assert gym["status"] == "configuration_required"
    assert "attendance_access_gate" not in gym["platform_gaps"]

    generic = rows["bug-tracking-issue-triage"]
    clinical = rows["personal-injury-case-management"]
    assert "clinical_record" not in generic["gap_categories"]
    assert clinical["status"] == "ready"
    assert "calculation.calculator" in clinical["app_blocks"]

    certification = rows["certification-program-management"]
    assert certification["status"] == "ready"
    assert "education-learning" in certification["feature_packs"]
    assert "renewal-operations" in certification["feature_packs"]

    procurement = rows["procurement-management-software"]
    assert procurement["status"] == "ready"
    assert "calculation.calculator" in procurement["app_blocks"]
    assert "billing-management" in procurement["feature_packs"]

    warehouse = rows["warehouse-management-system"]
    assert "logistics.shipment" in warehouse["app_blocks"]
    assert warehouse["status"] == "ready"
    assert "calculation.calculator" in warehouse["app_blocks"]

    analytics = rows["saas-analytics-dashboard"]
    assert analytics["status"] == "ready"
    assert analytics["gap_categories"] == {}
    assert "visualization.chart" in analytics["app_blocks"]
    assert "calculation.calculator" in analytics["app_blocks"]

    aviation = rows["aviation-maintenance-management-software"]
    assert "workflow.approval" in aviation["app_blocks"]
    assert "aviation_release_to_service" not in aviation["gap_categories"]
    assert aviation["status"] == "ready"
    assert aviation["gap_categories"] == {}
    assert rows["customer-health-score-dashboard"]["status"] == "ready"

    estimating = rows["construction-estimating-software"]
    assert estimating["status"] == "ready"
    assert "takeoff_engine" not in estimating["gap_categories"]
    assert rows["construction-management-software"]["status"] == "ready"

    lims = rows["laboratory-information-management-system-lims"]
    assert lims["status"] == "ready"
    assert "regulated_lims_claim" not in lims["gap_categories"]
    assert rows["laboratory-sample-tracking-software"]["status"] == "ready"

    ai_support = rows["ai-customer-support-dashboard"]
    assert ai_support["status"] == "ready"
    assert "ai-knowledge-assistant" in ai_support["feature_packs"]

    payments = rows["invoice-management-system"]
    assert payments["platform_readiness"] == "external_capability_required"
    assert payments["external_requirement"] in {
        "credential_configuration",
        "external_provider_required",
    }


def test_backend_work_queue_prioritizes_reusable_work_before_architecture_and_claims():
    report = build_readiness()
    queue = report["work_queue"]
    assert "automatic_renewal" not in {item["token"] for item in queue}
    assert queue == []
    assert "entitlements" not in {item["token"] for item in queue}
    assert "private_case_backend" not in {item["token"] for item in queue}