from unittest import TestCase

import pytest
from _pytest.python import Metafunc
from syrupy.assertion import SnapshotAssertion

from delivery_metadata.constants import (
    Genres,
    ParticipantRole,
)
from delivery_metadata.exceptions import (
    PrimaryArtistsMissing,
    SchemaValidationError,
)
from delivery_metadata.logic.metadata_formatters.ddex.ddex_ern_4_3 import doc_root
from delivery_metadata.logic.metadata_formatters.metadata_formatter import (
    DeliveryMetadataFormatter,
)
from delivery_metadata.models.delivery_rights import (
    DeliveryRights,
)
from delivery_metadata.models.schemas import DeliveryMetadata, Participant

from tests.unit.conftest import update_mock_object

E = doc_root.element_maker


def test_get_display_artists_non_classical(
    delivery_metadata_mock: DeliveryMetadata,
    audio_delivery_rights_mock_no_pricing: DeliveryRights,
    snapshot: SnapshotAssertion,
) -> None:
    DeliveryMetadataFormatter.__abstractmethods__ = frozenset()

    formatter = DeliveryMetadataFormatter(
        delivery_metadata_mock, audio_delivery_rights_mock_no_pricing
    )
    participants = [
        Participant(
            fullname="Very Big Star",
            roles={ParticipantRole.PERFORMER},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
        Participant(
            fullname="Very Big Star 2",
            roles={ParticipantRole.FEATURING},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
        Participant(
            fullname="Dwarf Producer",
            roles={ParticipantRole.PRODUCER},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
        Participant(
            fullname="Giant Ensemble",
            roles={ParticipantRole.ENSEMBLE},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
        Participant(
            fullname="Crowded Orchestra",
            roles={ParticipantRole.ORCHESTRA},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
        Participant(
            fullname="Novice Remixer",
            roles={ParticipantRole.REMIXER},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
    ]
    result = formatter._get_display_artists(participants)

    assert result == snapshot


def test_get_display_artists_classical(
    delivery_metadata_mock: DeliveryMetadata,
    audio_delivery_rights_mock_no_pricing: DeliveryRights,
    snapshot: SnapshotAssertion,
) -> None:
    updates = {"product.genre_id": Genres.CLASSICAL}
    updated_delivery_metadata_mock = update_mock_object(
        delivery_metadata_mock, DeliveryMetadata, updates
    )

    formatter = DeliveryMetadataFormatter(
        updated_delivery_metadata_mock, audio_delivery_rights_mock_no_pricing
    )
    participants = [
        Participant(
            fullname="Very Big Star",
            roles={ParticipantRole.PERFORMER},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
        Participant(
            fullname="Very Big Star 2",
            roles={ParticipantRole.FEATURING},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
        Participant(
            fullname="Dwarf Producer",
            roles={ParticipantRole.PRODUCER},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
        Participant(
            fullname="Giant Ensemble",
            roles={ParticipantRole.ENSEMBLE},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
        Participant(
            fullname="Crowded Orchestra",
            roles={ParticipantRole.ORCHESTRA},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
        Participant(
            fullname="Novice Remixer",
            roles={ParticipantRole.REMIXER},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
    ]
    result = formatter._get_display_artists(participants)

    assert result == snapshot


def test_get_release_display_artists_non_various_artists(
    delivery_metadata_mock: DeliveryMetadata,
    audio_delivery_rights_mock_no_pricing: DeliveryRights,
    snapshot: SnapshotAssertion,
) -> None:
    updated_participants = [
        Participant(
            fullname="Very Big Star",
            roles={ParticipantRole.PERFORMER},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
        Participant(
            fullname="Very Big Star 2",
            roles={ParticipantRole.FEATURING},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
        Participant(
            fullname="Dwarf Star",
            roles={ParticipantRole.FEATURING},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
    ]
    updates = {"product.participants": updated_participants}
    updated_delivery_metadata_mock = update_mock_object(
        delivery_metadata_mock, DeliveryMetadata, updates
    )
    formatter = DeliveryMetadataFormatter(
        updated_delivery_metadata_mock, audio_delivery_rights_mock_no_pricing
    )
    result = (
        formatter._get_release_display_artists()
        + formatter._get_release_non_primary_display_artists()
    )

    assert result == snapshot


def test_get_release_display_artists_various_artists(
    delivery_metadata_mock: DeliveryMetadata,
    audio_delivery_rights_mock_no_pricing: DeliveryRights,
    snapshot: SnapshotAssertion,
) -> None:
    updated_participants = [
        Participant(
            fullname="Very Big Star",
            roles={ParticipantRole.PERFORMER},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
        Participant(
            fullname="Very Big Star 2",
            roles={ParticipantRole.PERFORMER},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
        Participant(
            fullname="Dwarf Star",
            roles={ParticipantRole.PERFORMER},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
        Participant(
            fullname="Tiny Star",
            roles={ParticipantRole.PERFORMER},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
        Participant(
            fullname="Supernova Star",
            roles={ParticipantRole.PERFORMER},
            instruments=set(),
            label_participant_id=None,
            apple_music_id=None,
            spotify_id=None,
            global_participant_id=None,
            fullname_localizations=frozenset(),
        ),
    ]
    updates = {"product.participants": updated_participants}
    updated_delivery_metadata_mock = update_mock_object(
        delivery_metadata_mock, DeliveryMetadata, updates
    )
    formatter = DeliveryMetadataFormatter(
        updated_delivery_metadata_mock, audio_delivery_rights_mock_no_pricing
    )
    result = formatter._get_release_display_artists()

    assert result == snapshot


def test_get_release_display_artist_name_1_artist(
    delivery_metadata_mock: DeliveryMetadata,
    audio_delivery_rights_mock_no_pricing: DeliveryRights,
) -> None:
    DeliveryMetadataFormatter.__abstractmethods__ = frozenset()

    formatter = DeliveryMetadataFormatter(
        delivery_metadata_mock, audio_delivery_rights_mock_no_pricing
    )
    result = formatter._format_display_artist_name(
        [
            Participant(
                fullname="Very Big Star",
                roles={ParticipantRole.PERFORMER},
                instruments=set(),
                label_participant_id=None,
                apple_music_id=None,
                spotify_id=None,
                global_participant_id=None,
                fullname_localizations=frozenset(),
            )
        ]
    )

    assert result == "Very Big Star"


def test_get_release_display_artist_name_2_artists(
    delivery_metadata_mock: DeliveryMetadata,
    audio_delivery_rights_mock_no_pricing: DeliveryRights,
) -> None:
    DeliveryMetadataFormatter.__abstractmethods__ = frozenset()

    formatter = DeliveryMetadataFormatter(
        delivery_metadata_mock, audio_delivery_rights_mock_no_pricing
    )
    result = formatter._format_display_artist_name(
        [
            Participant(
                fullname="Very Big Star",
                roles={ParticipantRole.PERFORMER},
                instruments=set(),
                label_participant_id=None,
                apple_music_id=None,
                spotify_id=None,
                global_participant_id=None,
                fullname_localizations=frozenset(),
            ),
            Participant(
                fullname="Very Big Star 2",
                roles={ParticipantRole.PERFORMER},
                instruments=set(),
                label_participant_id=None,
                apple_music_id=None,
                spotify_id=None,
                global_participant_id=None,
                fullname_localizations=frozenset(),
            ),
        ],
    )

    assert result == "Very Big Star & Very Big Star 2"


def test_get_release_display_artist_name_3_artists(
    delivery_metadata_mock: DeliveryMetadata,
    audio_delivery_rights_mock_no_pricing: DeliveryRights,
) -> None:
    DeliveryMetadataFormatter.__abstractmethods__ = frozenset()

    formatter = DeliveryMetadataFormatter(
        delivery_metadata_mock, audio_delivery_rights_mock_no_pricing
    )
    result = formatter._format_display_artist_name(
        [
            Participant(
                fullname="Very Big Star",
                roles={ParticipantRole.PERFORMER},
                instruments=set(),
                label_participant_id=None,
                apple_music_id=None,
                spotify_id=None,
                global_participant_id=None,
                fullname_localizations=frozenset(),
            ),
            Participant(
                fullname="Very Big Star 2",
                roles={ParticipantRole.PERFORMER},
                instruments=set(),
                label_participant_id=None,
                apple_music_id=None,
                spotify_id=None,
                global_participant_id=None,
                fullname_localizations=frozenset(),
            ),
            Participant(
                fullname="Very Big Star 3",
                roles={ParticipantRole.PERFORMER},
                instruments=set(),
                label_participant_id=None,
                apple_music_id=None,
                spotify_id=None,
                global_participant_id=None,
                fullname_localizations=frozenset(),
            ),
        ],
    )

    assert result == "Very Big Star, Very Big Star 2 & Very Big Star 3"


def test_get_release_display_artist_name_4_artists(
    delivery_metadata_mock: DeliveryMetadata,
    audio_delivery_rights_mock_no_pricing: DeliveryRights,
) -> None:
    DeliveryMetadataFormatter.__abstractmethods__ = frozenset()

    formatter = DeliveryMetadataFormatter(
        delivery_metadata_mock, audio_delivery_rights_mock_no_pricing
    )

    result = formatter._format_display_artist_name(
        [
            Participant(
                fullname="Very Big Star",
                roles={ParticipantRole.PERFORMER},
                instruments=set(),
                label_participant_id=None,
                apple_music_id=None,
                spotify_id=None,
                global_participant_id=None,
                fullname_localizations=frozenset(),
            ),
            Participant(
                fullname="Very Big Star 2",
                roles={ParticipantRole.PERFORMER},
                instruments=set(),
                label_participant_id=None,
                apple_music_id=None,
                spotify_id=None,
                global_participant_id=None,
                fullname_localizations=frozenset(),
            ),
            Participant(
                fullname="Very Big Star 3",
                roles={ParticipantRole.PERFORMER},
                instruments=set(),
                label_participant_id=None,
                apple_music_id=None,
                spotify_id=None,
                global_participant_id=None,
                fullname_localizations=frozenset(),
            ),
            Participant(
                fullname="Smaller Star",
                roles={ParticipantRole.PERFORMER},
                instruments=set(),
                label_participant_id=None,
                apple_music_id=None,
                spotify_id=None,
                global_participant_id=None,
                fullname_localizations=frozenset(),
            ),
        ],
    )

    assert result == "Very Big Star, Very Big Star 2, Very Big Star 3 & Smaller Star"


def test_missing_primary_artists(
    delivery_metadata_mock: DeliveryMetadata,
    audio_delivery_rights_mock_no_pricing: DeliveryRights,
) -> None:
    DeliveryMetadataFormatter.__abstractmethods__ = frozenset()

    formatter = DeliveryMetadataFormatter(
        delivery_metadata_mock, audio_delivery_rights_mock_no_pricing
    )

    with pytest.raises(PrimaryArtistsMissing) as exc:
        formatter._format_display_artist_name(
            [
                Participant(
                    fullname="Big Time Producer",
                    roles={ParticipantRole.PRODUCER},
                    instruments=set(),
                    label_participant_id=None,
                    apple_music_id=None,
                    spotify_id=None,
                    global_participant_id=None,
                    fullname_localizations=frozenset(),
                ),
            ]
        )

    assert str(exc.value) == "Primary artist missing."
    assert exc.type == PrimaryArtistsMissing


@pytest.fixture
def wrapped_fixtures(
    request: Metafunc,
    delivery_metadata_mock: DeliveryMetadata,
    audio_delivery_rights_mock_no_pricing: DeliveryRights,
) -> None:
    request.cls.delivery_metadata = delivery_metadata_mock
    request.cls.audio_rights = audio_delivery_rights_mock_no_pricing


@pytest.mark.usefixtures("wrapped_fixtures")
class TestSchemaValidationError(TestCase):
    delivery_metadata: DeliveryMetadata
    audio_rights: DeliveryRights

    def test_ddex_4_3_schema_validate_with_error(self) -> None:
        DeliveryMetadataFormatter.__abstractmethods__ = frozenset()
        formatter = DeliveryMetadataFormatter(
            self.delivery_metadata,
            self.audio_rights,
        )

        with self.assertRaises(SchemaValidationError) as exc:
            formatter._schema_validate(
                E.NewReleaseMessage(),
                "delivery_metadata/logic/metadata_formatters/ddex/ddex_ern_4_3/ddex_ern_4_3.xsd",
            )

        self.assertEqual(
            str(exc.exception),
            "Schema validation error - Element '{http://ddex.net/xml/ern/43}NewReleaseMessage': The attribute 'AvsVersionId' is required but missing.",
        )
        self.assertEqual(
            exc.exception.xml_content,
            "<?xml version='1.0' encoding='UTF-8'?>\n<ern:NewReleaseMessage xmlns:ern=\"http://ddex.net/xml/ern/43\"/>\n",
        )