"""Unit tests for v43 party_list module."""

from unittest.mock import Mock

import pytest

from soundrecording_utils.constants.ddex import constants
from soundrecording_utils.ddex.v43.party_list import (
    _generate_party,
    generate_label_party,
    generate_party_list,
    generate_party_reference,
    generate_the_orchard_party,
)
from soundrecording_utils.metadata.types import Label, LabelParticipant, Product, Track, TrackParticipation


@pytest.fixture
def mock_participant():
    """Create a mock participant."""
    participant = Mock(spec=LabelParticipant)
    participant.uuid = 'test-uuid-123'
    participant.name = 'Test Artist'
    return participant


@pytest.fixture
def mock_participation(mock_participant):
    """Create a mock participation."""
    participation = Mock(spec=TrackParticipation)
    participation.participant = mock_participant
    participation.participated_as = 'MainArtist'
    return participation


@pytest.fixture
def mock_label():
    """Create a mock label."""
    label = Mock(spec=Label)
    label.uuid = 'label-uuid-456'
    label.name = 'Test Label'
    return label


@pytest.fixture
def mock_track_metadata(mock_label):
    """Create a mock track metadata."""
    track = Mock(spec=Track)
    product = Mock(spec=Product)
    product.label = mock_label
    track.product = product
    track.participations = []
    return track


def test_generate_party_reference(mock_participation):
    """Test party reference generation."""
    result = generate_party_reference(mock_participation)
    assert result == 'P-test-uuid-123'


def test_generate_party(mock_participation):
    """Test party node generation."""
    result = _generate_party(mock_participation)

    assert result.tag == 'Party'
    assert result.countchildren() == 3  # PartyReference, PartyName, PartyId


def test_generate_party_list_empty(mock_track_metadata):
    """Test party list generation with no participations."""
    mock_track_metadata.participations = []

    result = generate_party_list(mock_track_metadata)

    assert result == []


def test_generate_party_list_with_participations(
    mock_track_metadata, mock_participant
):
    """Test party list generation with participations."""
    participation1 = Mock(spec=TrackParticipation)
    participation1.participant = mock_participant
    participation1.participated_as = 'performer'

    mock_track_metadata.participations = [participation1]

    result = generate_party_list(mock_track_metadata)

    assert len(result) == 1
    assert result[0].tag == 'Party'


def test_generate_party_list_filters_roles(mock_track_metadata):
    """Test party list filters out non-display roles."""
    participant1 = Mock(spec=LabelParticipant)
    participant1.uuid = 'uuid-1'
    participant1.name = 'Artist 1'

    participation1 = Mock(spec=TrackParticipation)
    participation1.participant = participant1
    participation1.participated_as = 'SomeOtherRole'

    mock_track_metadata.participations = [participation1]

    result = generate_party_list(mock_track_metadata)

    assert len(result) == 0


def test_generate_party_list_unique_participants(mock_track_metadata):
    """Test party list deduplicates participants."""
    participant = Mock(spec=LabelParticipant)
    participant.uuid = 'same-uuid'
    participant.name = 'Same Artist'

    participation1 = Mock(spec=TrackParticipation)
    participation1.participant = participant
    participation1.participated_as = 'performer'

    participation2 = Mock(spec=TrackParticipation)
    participation2.participant = participant
    participation2.participated_as = 'producer'

    mock_track_metadata.participations = [participation1, participation2]

    result = generate_party_list(mock_track_metadata)

    assert len(result) == 1


def test_generate_party_list_with_user_defined_roles(mock_track_metadata):
    """Test party list includes user-defined roles."""
    participant = Mock(spec=LabelParticipant)
    participant.uuid = 'uuid-user-defined'
    participant.name = 'User Defined Artist'

    participation_user_defined = Mock(spec=TrackParticipation)
    participation_user_defined.participant = participant
    participation_user_defined.participated_as = 'producer'

    mock_track_metadata.participations = [participation_user_defined]

    result = generate_party_list(mock_track_metadata)

    assert len(result) == 1
    assert result[0].tag == 'Party'


def test_generate_the_orchard_party():
    """Test The Orchard party generation."""
    result = generate_the_orchard_party()

    assert result.tag == 'Party'
    assert result.countchildren() == 3
    assert result.PartyName.FullName == constants.ORCHARD_PARTY_NAME
    assert result.PartyReference == constants.ORCHARD_PARTY_REFERENCE


def test_generate_label_party(mock_track_metadata, mock_label):
    """Test label party generation."""
    result = generate_label_party(mock_track_metadata)

    assert result.tag == 'Party'
    assert result.countchildren() == 3
    assert result.PartyName.FullName == mock_label.name
    assert result.PartyId.ProprietaryId == mock_label.uuid
    assert result.PartyId.ProprietaryId.attrib['Namespace'] == constants.ORCHARD_PARTY_ID  # noqa: E501
    assert result.PartyReference == f'P-{mock_label.uuid}'


def test_generate_party_with_control_chars(mock_participant):
    """Test party generation removes control characters."""
    mock_participant.name = 'Test\x00Artist\x01Name'
    participation = Mock(spec=TrackParticipation)
    participation.participant = mock_participant

    result = _generate_party(participation)

    assert result.tag == 'Party'
    assert result.PartyName.FullName == 'TestArtistName'