"""Track logic tests."""

from unittest.mock import MagicMock

import pytest
from pytest_mock import MockerFixture

from contributor.logic.tracks import (
    get_track_participations_by_track_ids,
    get_track_participations_for_track,
)


@pytest.fixture
def session():
    return MagicMock()


@pytest.fixture
def label_profiles():
    return [{"profile_type": "LabelProfile", "profile_id": 7123, "roles": []}]


@pytest.fixture
def admin_profiles():
    return [{"profile_type": "ContentApp", "profile_id": 99, "roles": []}]


class TestGetTrackParticipationsByTrackIds:
    @pytest.fixture(autouse=True)
    def display_artists(self, mocker: MockerFixture) -> None:
        mocker.patch(
            "contributor.logic.tracks.display_artist_queries.get_by_track_ids",
            return_value=[],
        )

    def test_returns_track_participations_with_display_artists(
        self, mocker: MockerFixture, session, label_profiles
    ) -> None:
        mocker.patch(
            "contributor.logic.tracks.has_full_catalog_access",
            return_value=False,
        )
        mocker.patch(
            "contributor.logic.tracks.queries.get_by_track_ids",
            return_value=[
                {
                    "track": {"tuid": 101},
                    "participations": [
                        {
                            "contributor": {
                                "uuid": "550e8400-e29b-41d4-a716-446655440000"
                            },
                            "participated_as": "performer",
                            "track": {"tuid": 101},
                            "track_artist_id": 1001,
                        }
                    ],
                }
            ],
        )
        mocker.patch(
            "contributor.logic.tracks.display_artist_queries.get_by_track_ids",
            return_value=[
                {
                    "track": {"tuid": 101},
                    "display_artists": [
                        {
                            "contributor": {
                                "uuid": "11111111-2222-4333-8444-555555555555"
                            },
                            "role": "primary",
                        }
                    ],
                }
            ],
        )

        result = get_track_participations_by_track_ids(
            session,
            track_ids=[101],
            profiles=label_profiles,
        )

        assert result == [
            {
                "track": {"tuid": 101},
                "participations": [
                    {
                        "contributor": {"uuid": "550e8400-e29b-41d4-a716-446655440000"},
                        "participated_as": "performer",
                        "track": {"tuid": 101},
                        "track_artist_id": 1001,
                    }
                ],
                "display_artists": [
                    {
                        "contributor": {"uuid": "11111111-2222-4333-8444-555555555555"},
                        "role": "primary",
                    }
                ],
            }
        ]

    def test_filters_null_and_feature_to_primary_and_defaults_display_artists(
        self, mocker: MockerFixture, session, label_profiles
    ) -> None:
        mocker.patch(
            "contributor.logic.tracks.has_full_catalog_access",
            return_value=False,
        )
        mocker.patch(
            "contributor.logic.tracks.queries.get_by_track_ids",
            return_value=[
                {
                    "track": {"tuid": 101},
                    "participations": [
                        None,
                        {
                            "contributor": {
                                "uuid": "550e8400-e29b-41d4-a716-446655440000"
                            },
                            "participated_as": "feature_to_primary",
                            "track": {"tuid": 101},
                            "track_artist_id": 1001,
                        },
                        {
                            "contributor": {
                                "uuid": "aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee"
                            },
                            "participated_as": "performer",
                            "track": {"tuid": 101},
                            "track_artist_id": 1002,
                        },
                    ],
                }
            ],
        )

        result = get_track_participations_by_track_ids(
            session,
            track_ids=[101],
            profiles=label_profiles,
        )

        assert result == [
            {
                "track": {"tuid": 101},
                "participations": [
                    {
                        "contributor": {"uuid": "aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee"},
                        "participated_as": "performer",
                        "track": {"tuid": 101},
                        "track_artist_id": 1002,
                    }
                ],
                "display_artists": [],
            }
        ]

    def test_passes_is_admin_true_for_full_catalog_access(
        self, mocker: MockerFixture, session, admin_profiles
    ) -> None:
        mocker.patch(
            "contributor.logic.tracks.has_full_catalog_access",
            return_value=True,
        )
        mock = mocker.patch(
            "contributor.logic.tracks.queries.get_by_track_ids",
            return_value=[],
        )

        get_track_participations_by_track_ids(
            session,
            track_ids=[101],
            profiles=admin_profiles,
        )

        mock.assert_called_once_with(
            session=session,
            track_ids=[101],
            profile_ids=[],
            is_admin=True,
        )


class TestGetTrackParticipationsForTrack:
    def test_returns_first_track_result(
        self, mocker: MockerFixture, session, label_profiles
    ) -> None:
        mocker.patch(
            "contributor.logic.tracks.get_track_participations_by_track_ids",
            return_value=[
                {
                    "track": {"tuid": 101},
                    "participations": [],
                    "display_artists": [],
                }
            ],
        )

        result = get_track_participations_for_track(
            session,
            track_id=101,
            profiles=label_profiles,
        )

        assert result == {
            "track": {"tuid": 101},
            "participations": [],
            "display_artists": [],
        }

    def test_returns_none_when_not_found(
        self, mocker: MockerFixture, session, label_profiles
    ) -> None:
        mocker.patch(
            "contributor.logic.tracks.get_track_participations_by_track_ids",
            return_value=[],
        )

        assert (
            get_track_participations_for_track(
                session,
                track_id=101,
                profiles=label_profiles,
            )
            is None
        )