"""Test neo4_subaccount."""

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

import pytest

from permissions.models import neo4j_subaccount
from permissions.types import Subaccount


@pytest.mark.parametrize(
    'mock_data, expected_result',
    [
        pytest.param(
            [
                {'subaccount_uuid': 'subaccount-uuid-123', 'subaccount_id': 101},
                {'subaccount_uuid': 'subaccount-uuid-456', 'subaccount_id': 102},
            ],
            True,
            id='subaccounts_found',
        ),
        pytest.param([], False, id='no_subaccounts_found'),
    ],
)
@patch('permissions.models.identity.neo4j_connector.db_session')
def test_get_directly_accessible_subaccounts_by_profile(
    mock_db_session: MagicMock, mock_data: dict | None, expected_result: bool
) -> None:
    """Test get_directly_accessible_subaccounts_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_subaccount.get_directly_accessible_subaccounts_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, subaccount in enumerate(result):
            assert isinstance(subaccount, Subaccount)
            assert subaccount.subaccount_uuid == mock_data[i]['subaccount_uuid']
            assert subaccount.subaccount_id == mock_data[i]['subaccount_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]->(s:Subaccount)
    RETURN s.uuid as subaccount_uuid, s.id as subaccount_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