"""
Integration tests for Diagnostic Report verification, pathologist sign-off,
rejections, release, and versioned amendments.
"""

from datetime import UTC, date, datetime
from decimal import Decimal
from uuid import uuid4

import pytest
import pytest_asyncio
from httpx import AsyncClient
from sqlalchemy.ext.asyncio import AsyncSession

from app.core.permissions import PermissionCode
from app.core.security import create_access_token, hash_password
from app.models.lab import Lab
from app.models.order import OrderStatus, OrderTest, OrderTestStatus, VisitOrder
from app.models.patient import Gender, Patient
from app.models.report import Report, ReportStatus
from app.models.test import (
    Test as LabTest,
)
from app.models.test import (
    TestCategory as LabCategory,
)
from app.models.test import (
    TestParameter as LabParameter,
)
from app.models.test import (
    TestParameterRange as LabParameterRange,
)
from app.models.test import (
    TestResultType as LabResultType,
)
from app.models.user import User, UserPermissionOverride, UserRole
from app.repositories.permission_repository import PermissionRepository


@pytest_asyncio.fixture(autouse=True)
async def seed_perms(db_session: AsyncSession) -> None:
    """Seed permissions for RBAC checks."""
    repo = PermissionRepository()
    await repo.seed_permissions(db_session)


@pytest_asyncio.fixture
async def test_lab(db_session: AsyncSession) -> Lab:
    """Create test laboratory."""
    lab = Lab(name="Kathmandu Clinical Lab", address="Kathmandu")
    db_session.add(lab)
    await db_session.commit()
    await db_session.refresh(lab)
    return lab


@pytest_asyncio.fixture
async def branch_lab(db_session: AsyncSession) -> Lab:
    """Create branch laboratory for cross-branch isolation testing."""
    lab = Lab(name="Pokhara Clinical Branch", address="Pokhara")
    db_session.add(lab)
    await db_session.commit()
    await db_session.refresh(lab)
    return lab


@pytest_asyncio.fixture
async def pathologist_user(db_session: AsyncSession, test_lab: Lab) -> tuple[User, str]:
    """Create pathologist user with bearer token."""
    user = User(
        lab_id=test_lab.id,
        name="Dr. Sarita Giri, MD",
        phone="9841234567",
        email="sarita@munal.com",
        role=UserRole.PATHOLOGIST,
        hashed_password=hash_password("Pass123!"),
        is_active=True,
    )
    db_session.add(user)
    await db_session.commit()
    await db_session.refresh(user)
    token = create_access_token(
        subject=str(user.id),
        extra_claims={"email": user.email, "role": user.role.value, "lab_id": str(user.lab_id)},
    )
    return user, token


@pytest_asyncio.fixture
async def superadmin_user(db_session: AsyncSession, test_lab: Lab) -> tuple[User, str]:
    """Create superadmin user with bearer token (must forward, never verify)."""
    user = User(
        lab_id=test_lab.id,
        name="Super Admin",
        phone="9841234000",
        email="super@munal.com",
        role=UserRole.SUPERADMIN,
        hashed_password=hash_password("Pass123!"),
        is_active=True,
    )
    db_session.add(user)
    await db_session.commit()
    await db_session.refresh(user)
    token = create_access_token(
        subject=str(user.id),
        extra_claims={"email": user.email, "role": user.role.value, "lab_id": str(user.lab_id)},
    )
    return user, token


@pytest_asyncio.fixture
async def doctor_user(db_session: AsyncSession, test_lab: Lab) -> tuple[User, str]:
    """Create doctor user with bearer token (sees released reports, may verify)."""
    user = User(
        lab_id=test_lab.id,
        name="Dr. Doctor",
        phone="9841234001",
        email="doctor@munal.com",
        role=UserRole.DOCTOR,
        hashed_password=hash_password("Pass123!"),
        is_active=True,
    )
    db_session.add(user)
    await db_session.commit()
    await db_session.refresh(user)
    token = create_access_token(
        subject=str(user.id),
        extra_claims={"email": user.email, "role": user.role.value, "lab_id": str(user.lab_id)},
    )
    return user, token


@pytest_asyncio.fixture
async def phlebotomist_user(db_session: AsyncSession, test_lab: Lab) -> tuple[User, str]:
    """Create phlebotomist user with bearer token (unauthorized to verify reports)."""
    user = User(
        lab_id=test_lab.id,
        name="Phlebotomist Binod",
        phone="9841234568",
        email="binod@munal.com",
        role=UserRole.PHLEBOTOMIST,
        hashed_password=hash_password("Pass123!"),
        is_active=True,
    )
    db_session.add(user)
    await db_session.commit()
    await db_session.refresh(user)
    token = create_access_token(
        subject=str(user.id),
        extra_claims={"email": user.email, "role": user.role.value, "lab_id": str(user.lab_id)},
    )
    return user, token


@pytest_asyncio.fixture
async def branch_pathologist_user(db_session: AsyncSession, branch_lab: Lab) -> tuple[User, str]:
    """Create pathologist in a separate branch."""
    user = User(
        lab_id=branch_lab.id,
        name="Dr. Pokhara Pathologist",
        phone="9841234569",
        email="pokhara.path@munal.com",
        role=UserRole.PATHOLOGIST,
        hashed_password=hash_password("Pass123!"),
        is_active=True,
    )
    db_session.add(user)
    await db_session.commit()
    await db_session.refresh(user)
    token = create_access_token(
        subject=str(user.id),
        extra_claims={"email": user.email, "role": user.role.value, "lab_id": str(user.lab_id)},
    )
    return user, token


@pytest_asyncio.fixture
async def report_setup(
    db_session: AsyncSession,
    test_lab: Lab,
) -> tuple[VisitOrder, LabTest, LabParameter, Report]:
    """
    Setup patient, order, test parameter, and an active draft report with observations.
    """
    patient = Patient(
        lab_id=test_lab.id,
        patient_code="P26-00300",
        name="Hari Bahadur",
        gender=Gender.MALE,
        date_of_birth=date(1985, 3, 15),
        phone="9841112233",
    )
    db_session.add(patient)

    cat = LabCategory(lab_id=test_lab.id, name="Biochemistry", description="Routine biochemistry")
    db_session.add(cat)
    await db_session.flush()

    test = LabTest(
        lab_id=test_lab.id,
        category_id=cat.id,
        name="Lipid Profile",
        code="LIPID",
        result_type=LabResultType.COMPOSITE,
        price=Decimal("800.00"),
    )
    db_session.add(test)
    await db_session.flush()

    param = LabParameter(
        test_id=test.id,
        name="Total Cholesterol",
        unit="mg/dL",
        decimal_places=0,
        sort_order=1,
    )
    db_session.add(param)
    await db_session.flush()

    ref_range = LabParameterRange(
        parameter_id=param.id,
        gender=None,
        age_min=None,
        age_max=None,
        numeric_low=Decimal("120"),
        numeric_high=Decimal("200"),
    )
    db_session.add(ref_range)

    order = VisitOrder(
        lab_id=test_lab.id,
        patient_id=patient.id,
        order_number="ORD/26/000300",
        status=OrderStatus.PROCESSING,
    )
    db_session.add(order)
    await db_session.flush()

    order_test = OrderTest(
        order_id=order.id,
        test_id=test.id,
        price_at_order=test.price,
        status=OrderTestStatus.PROCESSING,
    )
    db_session.add(order_test)
    await db_session.flush()

    # Draft report with entered observations
    report = Report(
        order_id=order.id,
        version=1,
        status=ReportStatus.DRAFT,
        result_data={
            "order_number": order.order_number,
            "patient_age_at_test": 41,
            "patient_gender": "male",
            "parameters": {
                str(param.id): {
                    "parameter_id": str(param.id),
                    "parameter_name": param.name,
                    "unit": param.unit,
                    "value": "180",
                    "reference_low": "120",
                    "reference_high": "200",
                    "flag": "N",
                    "is_abnormal": False,
                    "notes": "Optimal",
                }
            },
            "last_updated_at": datetime.now(UTC).isoformat(),
        },
        notes="Specimen analyzed on automated biochemistry analyzer",
    )
    db_session.add(report)
    await db_session.commit()
    await db_session.refresh(order)
    await db_session.refresh(report)
    await db_session.refresh(test)
    await db_session.refresh(param)

    return order, test, param, report


@pytest.mark.asyncio
async def test_list_and_get_reports(
    client: AsyncClient,
    pathologist_user: tuple[User, str],
    report_setup: tuple[VisitOrder, LabTest, LabParameter, Report],
) -> None:
    """Test listing reports with filters and fetching full report details."""
    _, token = pathologist_user
    order, _, _, report = report_setup

    # List reports
    res = await client.get("/api/v1/reports", headers={"Authorization": f"Bearer {token}"})
    assert res.status_code == 200
    body = res.json()
    assert body["meta"]["total"] >= 1
    item = next(r for r in body["data"] if r["id"] == str(report.id))
    assert item["order_number"] == order.order_number
    assert item["version"] == 1
    assert item["status"] == "draft"

    # Detail report
    detail_res = await client.get(
        f"/api/v1/reports/{report.id}",
        headers={"Authorization": f"Bearer {token}"},
    )
    assert detail_res.status_code == 200
    detail = detail_res.json()["data"]
    assert detail["id"] == str(report.id)
    assert "parameters" in detail["result_data"]


@pytest.mark.asyncio
async def test_cross_branch_access_denied(
    client: AsyncClient,
    branch_pathologist_user: tuple[User, str],
    report_setup: tuple[VisitOrder, LabTest, LabParameter, Report],
) -> None:
    """Test user from other branch cannot view report."""
    _, token = branch_pathologist_user
    _, _, _, report = report_setup

    res = await client.get(
        f"/api/v1/reports/{report.id}",
        headers={"Authorization": f"Bearer {token}"},
    )
    assert res.status_code == 404


@pytest.mark.asyncio
async def test_submit_report_for_verification(
    client: AsyncClient,
    pathologist_user: tuple[User, str],
    report_setup: tuple[VisitOrder, LabTest, LabParameter, Report],
) -> None:
    """Test technician submitting draft report for pathologist review."""
    _, token = pathologist_user
    _, _, _, report = report_setup

    res = await client.post(
        f"/api/v1/reports/{report.id}/submit",
        json={"notes": "All calibration QC passed"},
        headers={"Authorization": f"Bearer {token}"},
    )
    assert res.status_code == 200
    data = res.json()["data"]
    assert data["status"] == "pending_verification"


@pytest.mark.asyncio
async def test_verify_report_workflow(
    client: AsyncClient,
    pathologist_user: tuple[User, str],
    report_setup: tuple[VisitOrder, LabTest, LabParameter, Report],
    db_session: AsyncSession,
) -> None:
    """Test pathologist authorizing and electronically signing report."""
    user, token = pathologist_user
    order, _, _, report = report_setup

    # First submit for verification
    await client.post(
        f"/api/v1/reports/{report.id}/submit",
        json={},
        headers={"Authorization": f"Bearer {token}"},
    )

    # Verify report
    verify_res = await client.post(
        f"/api/v1/reports/{report.id}/verify",
        json={
            "verification_reason": "Lipid levels within normal adult limits",
            "clinical_notes": "Advised lifestyle and routine annual check",
        },
        headers={"Authorization": f"Bearer {token}"},
    )
    assert verify_res.status_code == 200
    verified_data = verify_res.json()["data"]
    assert verified_data["status"] == "verified"
    assert verified_data["verified_by"]["id"] == str(user.id)
    assert verified_data["verified_at"] is not None

    # Check order status progressed to COMPLETED
    await db_session.refresh(order)
    assert order.status == OrderStatus.COMPLETED
    for ot in order.order_tests:
        assert ot.status == OrderTestStatus.VERIFIED


@pytest.mark.asyncio
async def test_verify_report_forbidden_for_unauthorized_role(
    client: AsyncClient,
    phlebotomist_user: tuple[User, str],
    report_setup: tuple[VisitOrder, LabTest, LabParameter, Report],
) -> None:
    """Test phlebotomist cannot verify or sign reports."""
    _, token = phlebotomist_user
    _, _, _, report = report_setup

    res = await client.post(
        f"/api/v1/reports/{report.id}/verify",
        json={"verification_reason": "Attempting unauthorized sign-off"},
        headers={"Authorization": f"Bearer {token}"},
    )
    assert res.status_code == 403


@pytest.mark.asyncio
async def test_verify_report_forbidden_for_superadmin(
    client: AsyncClient,
    superadmin_user: tuple[User, str],
    report_setup: tuple[VisitOrder, LabTest, LabParameter, Report],
) -> None:
    """Even superadmins must forward to a pathologist — never verify directly."""
    _, token = superadmin_user
    _, _, _, report = report_setup

    res = await client.post(
        f"/api/v1/reports/{report.id}/verify",
        json={"verification_reason": "Superadmin attempting direct sign-off"},
        headers={"Authorization": f"Bearer {token}"},
    )
    assert res.status_code == 403


@pytest.mark.asyncio
async def test_verifiers_list_pathologists_only(
    client: AsyncClient,
    phlebotomist_user: tuple[User, str],
) -> None:
    """Verifier dropdown lists pathologists/doctors — never superadmins."""
    _, token = phlebotomist_user
    res = await client.get("/api/v1/reports/verifiers", headers={"Authorization": f"Bearer {token}"})
    assert res.status_code == 200
    roles = {u["role"] for u in res.json()["data"]}
    assert roles <= {"pathologist", "doctor"}
    assert "superadmin" not in roles


@pytest.mark.asyncio
async def test_reject_report_workflow(
    client: AsyncClient,
    pathologist_user: tuple[User, str],
    report_setup: tuple[VisitOrder, LabTest, LabParameter, Report],
) -> None:
    """Test pathologist rejecting draft report with documented rationale."""
    _, token = pathologist_user
    _, _, _, report = report_setup

    res = await client.post(
        f"/api/v1/reports/{report.id}/reject",
        json={"reason": "Sample slightly lipemic, repeat analysis after high-speed centrifugation"},
        headers={"Authorization": f"Bearer {token}"},
    )
    assert res.status_code == 200
    data = res.json()["data"]
    assert data["status"] == "rejected"
    assert "lipemic" in data["verification_reason"]


@pytest.mark.asyncio
async def test_amend_verified_report_creates_version_2(
    client: AsyncClient,
    pathologist_user: tuple[User, str],
    report_setup: tuple[VisitOrder, LabTest, LabParameter, Report],
) -> None:
    """
    Test creating versioned amendment:
      1. Verify original report (v1).
      2. Amend with revised observation.
      3. Verifies v2 is created with previous_report_id pointing to v1.
      4. Verifies version history returns both v1 and v2.
    """
    _, token = pathologist_user
    order, _, param, report = report_setup

    # 1. Verify original
    await client.post(
        f"/api/v1/reports/{report.id}/verify",
        json={"verification_reason": "Initial sign-off"},
        headers={"Authorization": f"Bearer {token}"},
    )

    # 2. Amend report: corrected observation from 180 to 220 (High)
    amend_payload = {
        "reason": "Instrument recalibration adjustment for total cholesterol",
        "results": [{"parameter_id": str(param.id), "value": "220"}],
        "notes": "Amended per quality control recalibration protocol",
    }
    amend_res = await client.post(
        f"/api/v1/reports/{report.id}/amend",
        json=amend_payload,
        headers={"Authorization": f"Bearer {token}"},
    )
    assert amend_res.status_code == 200
    amended_data = amend_res.json()["data"]

    assert amended_data["version"] == 2
    assert amended_data["previous_report_id"] == str(report.id)
    assert amended_data["status"] == "draft"

    # Verify updated observation auto-flagged as High ('H')
    params = amended_data["result_data"]["parameters"]
    param_obs = params[str(param.id)]
    assert param_obs["value"] == "220"
    assert param_obs["flag"] == "H"
    assert param_obs["is_abnormal"] is True

    # 3. Check version lineage endpoint
    versions_res = await client.get(
        f"/api/v1/reports/order/{order.id}/versions",
        headers={"Authorization": f"Bearer {token}"},
    )
    assert versions_res.status_code == 200
    versions = versions_res.json()["data"]
    assert len(versions) == 2
    assert versions[0]["version"] == 2
    assert versions[1]["version"] == 1


@pytest.mark.asyncio
async def test_release_report_workflow(
    client: AsyncClient,
    pathologist_user: tuple[User, str],
    report_setup: tuple[VisitOrder, LabTest, LabParameter, Report],
) -> None:
    """Test releasing verified report to patient."""
    _, token = pathologist_user
    _, _, _, report = report_setup

    # Try releasing unverified draft -> 422
    unverified_res = await client.post(
        f"/api/v1/reports/{report.id}/release",
        json={},
        headers={"Authorization": f"Bearer {token}"},
    )
    assert unverified_res.status_code == 422

    # Verify report first
    await client.post(
        f"/api/v1/reports/{report.id}/verify",
        json={"verification_reason": "Authorized for release"},
        headers={"Authorization": f"Bearer {token}"},
    )

    # Now release
    release_res = await client.post(
        f"/api/v1/reports/{report.id}/release",
        json={"notes": "Printed and emailed to patient"},
        headers={"Authorization": f"Bearer {token}"},
    )
    assert release_res.status_code == 200
    released_data = release_res.json()["data"]
    assert released_data["status"] == "released"
    assert released_data["released_at"] is not None


@pytest.mark.asyncio
async def test_get_report_pdf_draft(
    client: AsyncClient,
    pathologist_user: tuple[User, str],
    report_setup: tuple[VisitOrder, LabTest, LabParameter, Report],
) -> None:
    """Test generating dynamic PDF for a draft report."""
    _, token = pathologist_user
    order, _, _, report = report_setup

    res = await client.get(
        f"/api/v1/reports/{report.id}/pdf",
        headers={"Authorization": f"Bearer {token}"},
    )
    assert res.status_code == 200
    assert "application/pdf" in res.headers["content-type"]
    assert res.content.startswith(b"%PDF-")
    assert (
        f'inline; filename="report_{order.order_number}_v{report.version}.pdf"'
        in res.headers["content-disposition"]
    )


@pytest.mark.asyncio
async def test_get_report_preview_html(
    client: AsyncClient,
    pathologist_user: tuple[User, str],
    report_setup: tuple[VisitOrder, LabTest, LabParameter, Report],
) -> None:
    """Test previewing report HTML with draft watermark and patient details."""
    _, token = pathologist_user
    order, _, param, report = report_setup

    res = await client.get(
        f"/api/v1/reports/{report.id}/preview",
        headers={"Authorization": f"Bearer {token}"},
    )
    assert res.status_code == 200
    assert "text/html" in res.headers["content-type"]
    html_text = res.text
    # Check patient, order, and watermark
    assert order.order_number in html_text
    assert "Hari Bahadur" in html_text
    assert "DRAFT — NOT FOR CLINICAL USE" in html_text
    assert param.name in html_text


@pytest.mark.asyncio
async def test_get_report_pdf_verified_and_amended(
    client: AsyncClient,
    pathologist_user: tuple[User, str],
    report_setup: tuple[VisitOrder, LabTest, LabParameter, Report],
) -> None:
    """Test PDF generation for verified report and amended report v2."""
    _, token = pathologist_user
    order, _, param, report = report_setup

    # 1. Verify report
    await client.post(
        f"/api/v1/reports/{report.id}/verify",
        json={"verification_reason": "Verified by pathologist"},
        headers={"Authorization": f"Bearer {token}"},
    )

    # 2. PDF for verified v1
    v1_pdf_res = await client.get(
        f"/api/v1/reports/{report.id}/pdf",
        headers={"Authorization": f"Bearer {token}"},
    )
    assert v1_pdf_res.status_code == 200
    assert v1_pdf_res.content.startswith(b"%PDF-")

    # 3. Create amendment v2
    amend_res = await client.post(
        f"/api/v1/reports/{report.id}/amend",
        json={
            "reason": "Corrected patient fasting observation",
            "modified_results": [{"parameter_id": str(param.id), "value": "180", "notes": "Fasting recheck"}],
        },
        headers={"Authorization": f"Bearer {token}"},
    )
    assert amend_res.status_code == 200
    amended_id = amend_res.json()["data"]["id"]

    # 4. Preview amended v2
    v2_preview_res = await client.get(
        f"/api/v1/reports/{amended_id}/preview",
        headers={"Authorization": f"Bearer {token}"},
    )
    assert v2_preview_res.status_code == 200
    html_v2 = v2_preview_res.text
    assert "AMENDMENT NOTICE (Version 2)" in html_v2
    assert "Corrected patient fasting observation" in html_v2

    # 5. Download amended v2 PDF
    v2_pdf_res = await client.get(
        f"/api/v1/reports/{amended_id}/pdf",
        headers={"Authorization": f"Bearer {token}"},
    )
    assert v2_pdf_res.status_code == 200
    assert v2_pdf_res.content.startswith(b"%PDF-")
    expected_header = f'inline; filename="report_{order.order_number}_v2.pdf"'
    assert expected_header in v2_pdf_res.headers["content-disposition"]


@pytest.mark.asyncio
async def test_report_pdf_cross_branch_access_denied(
    client: AsyncClient,
    branch_pathologist_user: tuple[User, str],
    report_setup: tuple[VisitOrder, LabTest, LabParameter, Report],
) -> None:
    """Test that a doctor/pathologist from another branch cannot access report PDF."""
    _, branch_token = branch_pathologist_user
    _, _, _, report = report_setup

    res = await client.get(
        f"/api/v1/reports/{report.id}/pdf",
        headers={"Authorization": f"Bearer {branch_token}"},
    )
    assert res.status_code == 404


@pytest.mark.asyncio
async def test_report_pdf_nonexistent(
    client: AsyncClient,
    pathologist_user: tuple[User, str],
) -> None:
    """Test requesting non-existent report ID returns 404."""
    _, token = pathologist_user
    random_id = uuid4()

    res = await client.get(
        f"/api/v1/reports/{random_id}/pdf",
        headers={"Authorization": f"Bearer {token}"},
    )
    assert res.status_code == 404


@pytest.mark.asyncio
async def test_report_pdf_denied_by_permission_override(
    client: AsyncClient,
    db_session: AsyncSession,
    test_lab: Lab,
    report_setup: tuple[VisitOrder, LabTest, LabParameter, Report],
) -> None:
    """Test that a staff user whose REPORT_READ is explicitly revoked is denied access (403)."""
    _, _, _, report = report_setup

    denied_user = User(
        lab_id=test_lab.id,
        name="Suspended Tech",
        phone="9841999888",
        email="suspended@munal.com",
        role=UserRole.GENERAL_USER,
        hashed_password=hash_password("Pass123!"),
        is_active=True,
    )
    db_session.add(denied_user)
    await db_session.flush()

    repo = PermissionRepository()
    perm = await repo.get_by_code(db_session, PermissionCode.REPORT_READ)
    assert perm is not None
    override = UserPermissionOverride(
        user_id=denied_user.id,
        permission_id=perm.id,
        is_granted=False,
    )
    db_session.add(override)
    await db_session.commit()

    token = create_access_token(
        subject=str(denied_user.id),
        extra_claims={
            "email": denied_user.email,
            "role": denied_user.role.value,
            "lab_id": str(denied_user.lab_id),
        },
    )
    res = await client.get(
        f"/api/v1/reports/{report.id}/pdf",
        headers={"Authorization": f"Bearer {token}"},
    )
    assert res.status_code == 403


@pytest.mark.asyncio
async def test_report_pdf_unauthenticated(
    client: AsyncClient,
    report_setup: tuple[VisitOrder, LabTest, LabParameter, Report],
) -> None:
    """Test that unauthenticated requests to report PDF are rejected (401)."""
    _, _, _, report = report_setup

    res = await client.get(f"/api/v1/reports/{report.id}/pdf")
    assert res.status_code == 401


@pytest.mark.asyncio
async def test_doctor_sees_released_report(
    client: AsyncClient,
    doctor_user: tuple[User, str],
    pathologist_user: tuple[User, str],
    report_setup: tuple[VisitOrder, LabTest, LabParameter, Report],
) -> None:
    """Doctor can read released reports but a released report is immutable."""
    _, doc_token = doctor_user
    _, path_token = pathologist_user
    _, _, _, report = report_setup
    doc_headers = {"Authorization": f"Bearer {doc_token}"}
    path_headers = {"Authorization": f"Bearer {path_token}"}

    # Released fixture? Submit + verify via pathologist first.
    await client.post(f"/api/v1/reports/{report.id}/submit", json={}, headers=path_headers)
    verify_res = await client.post(
        f"/api/v1/reports/{report.id}/verify",
        json={"verification_reason": "Looks good"},
        headers=path_headers,
    )
    assert verify_res.status_code == 200

    got = await client.get(f"/api/v1/reports/{report.id}", headers=doc_headers)
    assert got.status_code == 200
    assert got.json()["data"]["status"] == "verified"

    listed = await client.get("/api/v1/reports", headers=doc_headers)
    assert listed.status_code == 200
    assert any(r["id"] == str(report.id) for r in listed.json()["data"])