"""Tests for product participation Neo4j queries."""

from unittest.mock import MagicMock

import pytest

from contributor.queries.neo4j.products import (
    get_by_label_participant_uuid,
    get_by_product_id,
)


@pytest.fixture
def label_participant_uuid():
    return "550e8400-e29b-41d4-a716-446655440000"


@pytest.fixture
def participations_record(label_participant_uuid):
    record = MagicMock()
    record.__getitem__ = lambda self, key: {
        "contributor": {"uuid": label_participant_uuid},
        "participations": [
            {
                "contributor": {"uuid": label_participant_uuid},
                "participated_as": "performer",
                "product": {"product_id": 101},
                "release_artist_id": 1001,
            },
            {
                "contributor": {"uuid": label_participant_uuid},
                "participated_as": "featuring",
                "product": {"product_id": 202},
                "release_artist_id": 2002,
            },
        ],
    }[key]
    record.get = lambda key, default=None: {
        "contributor": {"uuid": label_participant_uuid},
        "participations": [
            {
                "contributor": {"uuid": label_participant_uuid},
                "participated_as": "performer",
                "product": {"product_id": 101},
                "release_artist_id": 1001,
            },
            {
                "contributor": {"uuid": label_participant_uuid},
                "participated_as": "featuring",
                "product": {"product_id": 202},
                "release_artist_id": 2002,
            },
        ],
    }.get(key, default)
    return record


@pytest.fixture
def session(participations_record):
    session = MagicMock()
    result = MagicMock()
    result.single.return_value = participations_record
    session.run.return_value = result
    return session


@pytest.fixture
def empty_session():
    session = MagicMock()
    result = MagicMock()
    result.single.return_value = None
    session.run.return_value = result
    return session


@pytest.fixture
def no_participations_record(label_participant_uuid):
    """LP exists but has no PARTICIPATED_IN relationships (OPTIONAL MATCH returns nulls)."""
    record = MagicMock()
    record.__getitem__ = lambda self, key: {
        "contributor": {"uuid": label_participant_uuid},
        "participations": [
            {
                "contributor": {"uuid": label_participant_uuid},
                "participated_as": None,
                "product": None,
                "release_artist_id": None,
            }
        ],
    }[key]
    record.get = lambda key, default=None: {
        "contributor": {"uuid": label_participant_uuid},
        "participations": [
            {
                "contributor": {"uuid": label_participant_uuid},
                "participated_as": None,
                "product": None,
                "release_artist_id": None,
            }
        ],
    }.get(key, default)
    return record


class TestGetByLabelParticipantUuid:
    def test_returns_participations(self, session, label_participant_uuid) -> None:
        result = get_by_label_participant_uuid(
            session,
            uuid=label_participant_uuid,
            profile_ids=[7123],
        )
        assert result == {
            "contributor": {"uuid": label_participant_uuid},
            "participations": [
                {
                    "contributor": {"uuid": label_participant_uuid},
                    "participated_as": "performer",
                    "product": {"product_id": 101},
                    "release_artist_id": 1001,
                },
                {
                    "contributor": {"uuid": label_participant_uuid},
                    "participated_as": "featuring",
                    "product": {"product_id": 202},
                    "release_artist_id": 2002,
                },
            ],
        }

    def test_returns_participations_as_admin(
        self, session, label_participant_uuid
    ) -> None:
        result = get_by_label_participant_uuid(
            session,
            uuid=label_participant_uuid,
            profile_ids=[],
            is_admin=True,
        )
        assert result is not None
        assert len(result["participations"]) == 2

    def test_returns_none_when_not_found(self, empty_session) -> None:
        assert (
            get_by_label_participant_uuid(
                empty_session, uuid="no-match", profile_ids=[7123]
            )
            is None
        )

    def test_filters_null_participations_from_optional_match(
        self, no_participations_record, label_participant_uuid
    ) -> None:
        session = MagicMock()
        result = MagicMock()
        result.single.return_value = no_participations_record
        session.run.return_value = result

        pp = get_by_label_participant_uuid(
            session,
            uuid=label_participant_uuid,
            profile_ids=[7123],
        )
        assert pp is not None
        assert pp["participations"] == []


class TestGetByProductId:
    def test_returns_contributors(self, label_participant_uuid) -> None:
        from unittest.mock import patch

        product_result = {
            "product": {"product_id": 12345},
            "contributors": [
                {
                    "contributor": {"uuid": label_participant_uuid},
                    "participated_as": "performer",
                    "product": {"product_id": 12345},
                    "release_artist_id": 1001,
                },
                {
                    "contributor": {"uuid": "aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee"},
                    "participated_as": "featuring",
                    "product": {"product_id": 12345},
                    "release_artist_id": 1002,
                },
            ],
        }
        with patch(
            "contributor.queries.neo4j.product_participations.get_by_product_ids",
            return_value=[product_result],
        ):
            session = MagicMock()
            result = get_by_product_id(session, product_id=12345, profile_ids=[7123])
            assert result == product_result

    def test_returns_none_when_product_not_found(self) -> None:
        from unittest.mock import patch

        with patch(
            "contributor.queries.neo4j.product_participations.get_by_product_ids",
            return_value=[],
        ):
            session = MagicMock()
            result = get_by_product_id(session, product_id=0, profile_ids=[7123])
            assert result is None

    def test_filters_null_contributors_from_optional_match(
        self, label_participant_uuid
    ) -> None:
        from unittest.mock import patch

        product_result = {
            "product": {"product_id": 12345},
            "contributors": [None],
        }
        with patch(
            "contributor.queries.neo4j.product_participations.get_by_product_ids",
            return_value=[product_result],
        ):
            session = MagicMock()
            pp = get_by_product_id(session, product_id=12345, profile_ids=[7123])
            assert pp is not None
            assert pp["contributors"] == [None]

    def test_filters_null_release_artist_ids(self, label_participant_uuid) -> None:
        from unittest.mock import patch

        product_result = {
            "product": {"product_id": 12345},
            "contributors": [
                {
                    "contributor": {"uuid": label_participant_uuid},
                    "participated_as": "performer",
                    "product": {"product_id": 12345},
                    "release_artist_id": None,
                }
            ],
        }
        with patch(
            "contributor.queries.neo4j.product_participations.get_by_product_ids",
            return_value=[product_result],
        ):
            session = MagicMock()
            pp = get_by_product_id(session, product_id=12345, profile_ids=[7123])
            assert pp is not None
            assert len(pp["contributors"]) == 1
            assert pp["contributors"][0]["release_artist_id"] is None