"""
[DELETE] /org/ is not tested because the testing client cannot attach a body to a delete request.
"""

from typing import Any

import pytest
from httpx import AsyncClient

from .conftest import generate_query_and_status, standard_test


pytestmark = [
    pytest.mark.org_module,
]


@pytest.mark.parametrize("query, expected_status", generate_query_and_status(["org_id"]))
@pytest.mark.anyio
async def test_get_org_status_checks(
    default_client: AsyncClient, query: str, expected_status: int
):
    resp = await default_client.get(f"/org?{query}")

    assert resp.status_code == expected_status


@pytest.mark.parametrize(
    "body, expected_status",
    [
        ({"name": 42}, 422),
        ({}, 422),
        ({"name": "New Test Org", "intake_questionnaire": {"question_one": 42}}, 422),
    ],
)
@pytest.mark.anyio
async def test_post_org_status_checks(
    default_client: AsyncClient, body: dict[str, str], expected_status: int
):
    resp = await default_client.post("/org", json=body)

    assert resp.status_code == expected_status


@pytest.mark.parametrize(
    "body, expected_status",
    [
        ({"organisation_id": 42}, 404),
        ({"organisation_id": "Org One"}, 422),
        ({"organisation_id": ""}, 422),
        ({}, 422),
        (
            {
                "organisation_id": "1",
                "intake_questionnaire": {"question_one": 42},
                "partial": True,
            },
            422,
        ),
        (
            {"organisation_id": "1", "intake_questionnaire": {"question_one": "valid"}},
            422,
        ),
        (
            {
                "organisation_id": "1",
                "intake_questionnaire": {"question_one": "valid"},
                "partial": 42,
            },
            422,
        ),
    ],
)
@pytest.mark.anyio
async def test_patch_questionnaire_partial_status_checks(
    default_client: AsyncClient, body: dict[str, str], expected_status: int
):
    resp = await default_client.patch("/org/questionnaire", json=body)

    assert resp.status_code == expected_status


@pytest.mark.anyio
async def test_patch_org_questionnaire_submit_success(default_client: AsyncClient):
    resp = await default_client.patch(
        "/org/questionnaire",
        json={
            "organisation_id": 3,
            "intake_questionnaire": {
                "question_one": "new answer one",
                "question_two": None,
                "question_three": None,
            },
            "partial": False,
        },
    )
    data = resp.json()

    assert resp.status_code == 200
    assert data["name"] == "Org Three"
    assert data["status"] == "submitted"
    assert "intake_questionnaire" in data
    assert isinstance(data["intake_questionnaire"], dict)
    metadata = data["intake_questionnaire"]["metadata"]
    assert metadata["version"] == 0
    assert metadata["submission_date"] is not None
    questions = data["intake_questionnaire"]["questions"]
    assert questions["question_one"] == "new answer one"
    assert questions["question_two"] == "answer two"
    assert questions["question_three"] is None


@pytest.mark.parametrize(
    "status", ["partial", "submitted", "remediation", "approved", "rejected", "removed"]
)
@pytest.mark.anyio
async def test_patch_org_status_success(default_client: AsyncClient, status: str):
    resp = await default_client.patch(
        "/org/status", json={"organisation_id": 1, "status": status}
    )
    data = resp.json()

    assert resp.status_code == 200
    assert data["name"] == "Org One"
    assert data["status"] == status


@pytest.mark.parametrize(
    "body, expected_status",
    [
        ({"organisation_id": 42}, 404),
        ({"organisation_id": "Org One"}, 422),
        ({"organisation_id": ""}, 422),
        ({}, 422),
        ({"organisation_id": "1", "status": True}, 422),
        ({"organisation_id": "1", "status": 42}, 422),
    ],
)
@pytest.mark.anyio
async def test_patch_org_status_status_checks(
    default_client: AsyncClient, body: dict[str, str], expected_status: int
):
    resp = await default_client.patch("/org/status", json=body)

    assert resp.status_code == expected_status


@pytest.mark.parametrize("query, expected_status", generate_query_and_status(["org_id"]))
@pytest.mark.anyio
async def test_get_org_users_status_checks(
    default_client: AsyncClient, query: str, expected_status: int
):
    resp = await default_client.get(f"/org/users?{query}")

    assert resp.status_code == expected_status


@pytest.mark.parametrize(
    "body, expected_status",
    [
        ({"organisation_id": 42}, 404),
        ({}, 422),
        ({"organisation_id": 1, "user_id": "id"}, 422),
        ({"user_id": 2}, 422),
        ({"organisation_id": 1, "user_id": 42}, 404),
        ({"organisation_id": 1, "user_id": 1}, 409),
    ],
)
@pytest.mark.anyio
async def test_post_org_user_status_checks(
    default_client: AsyncClient, body: dict[str, str], expected_status: int
):
    resp = await default_client.post("/org/user", json=body)

    assert resp.status_code == expected_status


@pytest.mark.parametrize(
    "body, expected_status",
    [
        ({"organisation_id": 42, "user_id": 2}, 404),
        ({"organisation_id": "Org One", "user_id": 2}, 422),
        ({"organisation_id": "", "user_id": 2}, 422),
        ({}, 422),
        ({"user_id": 2}, 422),
        ({"user_id": 42}, 404),
        ({"organisation_id": 1, "user_id": "Test User"}, 422),
    ],
)
@pytest.mark.anyio
async def test_patch_root_user_status_checks(
    default_client: AsyncClient, body: dict[str, str], expected_status: int
):
    resp = await default_client.patch("/org/root_user", json=body)

    assert resp.status_code == expected_status


@pytest.mark.anyio
async def test_patch_org_root_user_non_member(default_client: AsyncClient):
    resp = await default_client.patch(
        "/org/root_user", json={"organisation_id": 1, "user_id": 3}
    )
    data = resp.json()

    assert resp.status_code == 422
    assert data["detail"] == "This user does not belong to your organisation."


@pytest.mark.parametrize("query, expected_status", generate_query_and_status(["org_id"]))
@pytest.mark.anyio
async def test_get_org_groups_status_checks(
    default_client: AsyncClient, query: str, expected_status: int
):
    resp = await default_client.get(f"/org/groups?{query}")

    assert resp.status_code == expected_status


@pytest.mark.parametrize("contact_type", ["billing", "security", "owner"])
@pytest.mark.anyio
async def test_get_org_contact_success(default_client: AsyncClient, contact_type: str):
    resp = await default_client.get(f"/org/contact?org_id=1&contact_type={contact_type}")
    data = resp.json()

    assert resp.status_code == 200

    assert "organisation" in data
    assert data["organisation"]["id"] == 1
    assert data["organisation"]["name"] == "Org One"

    attributes = [
        "email",
        "first_name",
        "last_name",
        "phonenumber",
        "vat_number",
        "address",
    ]

    for attribute in attributes:
        assert attribute in data["contact"]

    address_attributes = [
        "post_office_box_number",
        "street_address",
        "street_address_line_2",
        "locality",
        "address_region",
        "country_code",
        "postal_code",
    ]

    for attribute in address_attributes:
        assert attribute in data["contact"]["address"]


@pytest.mark.parametrize(
    "query, expected_status",
    [
        ("org_id=42&contact_type=billing", 404),
        ("org_id=banana&contact_type=billing", 422),
        ("", 422),
        ("org_id=1&contact_type=contact", 422),
        ("contact_type=billing", 422),
    ],
)
@pytest.mark.anyio
async def test_get_org_contact_status_checks(
    default_client: AsyncClient, query: str, expected_status: int
):
    resp = await default_client.get(f"/org/contact?{query}")

    assert resp.status_code == expected_status


@pytest.mark.parametrize(
    "key, value",
    [
        ("email", "user@example.com"),
        ("first_name", "John"),
        ("last_name", "Doe"),
        ("phonenumber", "+441234567890"),
        ("vat_number", "GB123456789"),
        ("post_office_box_number", "PO Box 123"),
        ("street_address", "123 Example Street"),
        ("street_address_line_2", "Suite 4B"),
        ("locality", "Glasgow"),
        ("address_region", "Glasgow City"),
        ("country_code", "GB"),
        ("postal_code", "G1 1AA"),
    ],
)
@pytest.mark.anyio
async def test_patch_org_contact_success(default_client: AsyncClient, key: str, value: str):
    resp = await default_client.patch(
        "/org/contact",
        json={"organisation_id": 1, "contact_type": "billing", key: value},
    )
    assert resp.status_code == 200

    data = resp.json()

    assert "organisation" in data
    assert data["organisation"]["id"] == 1
    assert data["organisation"]["name"] == "Org One"

    attributes = [
        "email",
        "first_name",
        "last_name",
        "phonenumber",
        "vat_number",
        "address",
    ]

    for attribute in attributes:
        assert attribute in data["contact"]

    address_attributes = [
        "post_office_box_number",
        "street_address",
        "street_address_line_2",
        "locality",
        "address_region",
        "country_code",
        "postal_code",
    ]

    for attribute in address_attributes:
        assert attribute in data["contact"]["address"]

    if key in data["contact"]:
        assert data["contact"][key] == value
    elif key in data["contact"]["address"]:
        assert data["contact"]["address"][key] == value
    else:
        pytest.fail(f"Invalid contact key: {key}")


@pytest.mark.parametrize(
    "body, expected_status",
    [
        ({"organisation_id": 42, "contact_type": "billing"}, 404),
        ({"organisation_id": 1, "contact_type": "security"}, 200),
        ({"organisation_id": 1, "contact_type": "owner"}, 200),
        ({"organisation_id": "Org One", "contact_type": "billing"}, 422),
        ({"organisation_id": "", "contact_type": "billing"}, 422),
        ({}, 422),
        ({"organisation_id": 1, "contact_type": "not_real"}, 422),
        ({"organisation_id": 1, "contact_type": 42}, 422),
        ({"organisation_id": 1, "contact_type": ""}, 422),
    ],
)
@pytest.mark.anyio
async def test_patch_org_contact_status_checks(
    default_client: AsyncClient, body: dict[str, str], expected_status: int
):
    resp = await default_client.patch("/org/contact", json=body)

    assert resp.status_code == expected_status


@pytest.mark.anyio
async def test_get_org_standard(
    default_client: AsyncClient, route_data: dict[str, dict[str, Any]]
):
    method = "GET"
    path = "/org"
    auth_level = "Root User"
    query = "?org_id=1"
    body = {}
    expected_data = {
        "organisations": [
            {
                "organisation_id": 1,
                "name": "Org One",
                "status": "approved",
                "root_user_email": "admin@test.com",
                "intake_questionnaire": {
                    "metadata": {"version": 0, "submission_date": None},
                    "questions": {
                        "question_one": None,
                        "question_two": "answer two",
                        "question_three": None,
                    },
                },
                "billing_contact": {"id": 1, "email": "billing@orgone.com"},
                "owner_contact": {"id": 2, "email": "owner@orgone.com"},
                "security_contact": {"id": 3, "email": "security@orgone.com"},
            }
        ]
    }

    await standard_test(
        default_client, method, path, auth_level, query, body, expected_data, route_data
    )


@pytest.mark.anyio
async def test_post_org_standard(
    default_client: AsyncClient, route_data: dict[str, dict[str, Any]]
):
    method = "POST"
    path = "/org"
    auth_level = "User"
    query = ""
    body = {"name": "New Test Org"}
    expected_data = {"id": 4, "name": "New Test Org", "status": "partial"}

    await standard_test(
        default_client, method, path, auth_level, query, body, expected_data, route_data
    )


@pytest.mark.anyio
async def test_patch_org_questionnaire_partial_standard(
    default_client: AsyncClient, route_data: dict[str, dict[str, Any]]
):
    method = "PATCH"
    path = "/org/questionnaire"
    auth_level = "Root User"
    query = ""
    body = {
        "organisation_id": 3,
        "intake_questionnaire": {
            "question_one": "new answer one",
            "question_two": None,
            "question_three": None,
        },
        "partial": True,
    }
    expected_data = {
        "id": 3,
        "name": "Org Three",
        "status": "partial",
        "intake_questionnaire": {
            "metadata": {"version": 0, "submission_date": None},
            "questions": {
                "question_one": "new answer one",
                "question_two": "answer two",
                "question_three": None,
            },
        },
    }

    await standard_test(
        default_client, method, path, auth_level, query, body, expected_data, route_data
    )


@pytest.mark.anyio
async def test_get_org_users_standard(
    default_client: AsyncClient, route_data: dict[str, dict[str, Any]]
):
    method = "GET"
    path = "/org/users"
    auth_level = "Root User"
    query = "?org_id=1"
    body = {}
    expected_data = {
        "users": [
            {"email": "admin@test.com", "id": 1},
            {"email": "user@orgone.com", "id": 2},
        ],
        "organisation": {"id": 1, "name": "Org One"},
    }

    await standard_test(
        default_client, method, path, auth_level, query, body, expected_data, route_data
    )


@pytest.mark.anyio
async def test_post_org_user_standard(
    default_client: AsyncClient, route_data: dict[str, dict[str, Any]]
):
    method = "POST"
    path = "/org/user"
    auth_level = "Super Admin"
    query = ""
    body = {"organisation_id": 1, "user_id": 3}
    expected_data = {
        "users": [
            {"email": "admin@test.com", "id": 1},
            {"email": "user@orgone.com", "id": 2},
            {"email": "root@orgtwo.com", "id": 3},
        ],
        "organisation": {"id": 1, "name": "Org One"},
    }

    await standard_test(
        default_client, method, path, auth_level, query, body, expected_data, route_data
    )


@pytest.mark.anyio
async def test_patch_org_root_user_standard(
    default_client: AsyncClient, route_data: dict[str, dict[str, Any]]
):
    method = "PATCH"
    path = "/org/root_user"
    auth_level = "Super Admin"
    query = ""
    body = {"organisation_id": 1, "user_id": 2}
    expected_data = {"name": "Org One", "root_user_email": "user@orgone.com"}

    await standard_test(
        default_client, method, path, auth_level, query, body, expected_data, route_data
    )


@pytest.mark.anyio
async def test_get_org_groups_standard(
    default_client: AsyncClient, route_data: dict[str, dict[str, Any]]
):
    method = "GET"
    path = "/org/groups"
    auth_level = "Root User"
    query = "?org_id=1"
    body = {}
    expected_data = {
        "groups": [
            {"name": "Org One Group", "id": 1},
            {"name": "Org One Group Two", "id": 3},
        ],
        "organisation": {"id": 1, "name": "Org One"},
    }

    await standard_test(
        default_client, method, path, auth_level, query, body, expected_data, route_data
    )


@pytest.mark.anyio
async def test_delete_org_standard(
    default_client: AsyncClient, route_data: dict[str, dict[str, Any]]
):
    method = "DELETE"
    path = "/org"
    auth_level = "Super Admin"
    query = "?org_id=1"
    body = {}
    expected_data = {}

    await standard_test(
        default_client, method, path, auth_level, query, body, expected_data, route_data
    )


@pytest.mark.anyio
async def test_delete_org_users_standard(
    default_client: AsyncClient, route_data: dict[str, dict[str, Any]]
):
    method = "DELETE"
    path = "/org/user"
    auth_level = "Root User"
    query = "?org_id=1&user_id=2"
    body = {}
    expected_data = {}

    await standard_test(
        default_client, method, path, auth_level, query, body, expected_data, route_data
    )


@pytest.mark.anyio
async def test_delete_preapproval_org_standard(
    default_client: AsyncClient, route_data: dict[str, dict[str, Any]]
):
    method = "DELETE"
    path = "/org/self"
    auth_level = "Root User"
    query = "?org_id=3"
    body = {}
    expected_data = {}

    await standard_test(
        default_client, method, path, auth_level, query, body, expected_data, route_data
    )