"""Test neo4_vendor."""

import textwrap
import uuid
from unittest.mock import MagicMock, patch

import pytest

from permissions.models import neo4j_vendor
from permissions.types import Vendor


@pytest.mark.parametrize(
    'mock_data, expected_result, test_id',
    [
        pytest.param(
            [
                {'vendor_uuid': 'vendor-uuid-123', 'vendor_id': 101},
                {'vendor_uuid': 'vendor-uuid-456', 'vendor_id': 102},
            ],
            True,
            'vendors_found',
            id='vendors_found',
        ),
        pytest.param(
            [
                {'vendor_uuid': 'vendor-uuid-star', 'vendor_id': '*'},
            ],
            True,
            'star_vendor_found',
            id='star_vendor_found',
        ),
        pytest.param([], False, 'no_vendors_found', id='no_vendors_found'),
    ],
)
@patch('permissions.models.identity.neo4j_connector.db_session')
def test_get_directly_accessible_vendors_by_profile(
    mock_db_session: MagicMock, mock_data: dict | None, expected_result: bool, test_id: str
) -> None:
    """Test get_directly_accessible_vendors_by_profile."""
    # set up test data
    identity_id = uuid.uuid4()
    profile_id = 12345
    profile_type = 'AbacusProfile'

    # set up mock session
    mock_session = MagicMock()
    mock_db_session.return_value.__enter__.return_value = mock_session

    # mock the database result
    mock_result = MagicMock()

    # configure the __iter__ method to return mock data
    mock_result.__iter__.return_value = [{k: v for k, v in item.items()} for item in mock_data]
    mock_session.run.return_value = mock_result

    result = neo4j_vendor.get_directly_accessible_vendors_by_profile(
        identity_id=identity_id, profile_id=profile_id, profile_type=profile_type
    )

    # assert result matches expected
    assert isinstance(result, list)

    if expected_result:
        assert len(result) == len(mock_data)
        for i, vendor in enumerate(result):
            assert isinstance(vendor, Vendor)
            assert vendor.vendor_uuid == mock_data[i]['vendor_uuid']
            assert vendor.vendor_id == mock_data[i]['vendor_id']
    else:
        assert len(result) == 0

    # Verify the Neo4j query was called with correct parameters
    mock_session.run.assert_called_once()

    # Get the query string and parameters from the call
    call_args = mock_session.run.call_args
    actual_query = call_args[0][0]

    # test the query was called with correct cypher
    expected_query = textwrap.dedent("""
    MATCH (i:Identity {id: $identity_id})-[:HAS_PROFILE]->
    (p:Profile {profileType: $profile_type, profileId: $profile_id})
    MATCH (p)-[:HAS_ACCESS_TO|HAS_ADMIN_ACCESS_TO]->(v:Vendor)
    RETURN v.uuid as vendor_uuid, v.vendorId as vendor_id""").strip()

    assert actual_query.strip() == expected_query

    # test the query parameters
    actual_params = call_args[1]
    assert actual_params['identity_id'] == str(identity_id)
    assert actual_params['profile_id'] == profile_id
    assert actual_params['profile_type'] == profile_type