"""A."""
from typing import List

from .e import E
from .sound_recording import generate_reference_title
from .track import generate_display_artist_name
from .track import generate_p_line
from .track import generate_track_display_artists
from ..constants.ddex import EXPLICIT_STATUS_LOOKUP_TABLE
from ..constants.ddex import DEFAULT_TERRITORY_CODE
from .util import deduplicate_territories
from .util import get_primary_track

from soundrecording_utils.metadata.types import OrchardSoundRecording
from soundrecording_utils.metadata.types import ProductStatus
from soundrecording_utils.metadata.types import Track


def _generate_p_lines(
    sound_recording_metadata: OrchardSoundRecording,
):
    """Generate all unique P Lines for an OrchardSoundRecording."""
    return [
        generate_p_line(p_info)
        for p_info in sorted(set(
            track.p_info
            for track in sound_recording_metadata.track_connection.tracks
            if track.product.status == ProductStatus.in_content and track.p_info  # noqa:E501
        ))
    ]


def _generate_release_details_by_territory(
    territories: List[str],
    track_metadata: Track,
):
    return E(
        'ReleaseDetailsByTerritory',
        *(
            E('TerritoryCode', territory)
            for territory
            in territories
        ),
        generate_display_artist_name(track_metadata.participations),
        E(
            'LabelName',
            track_metadata.product.label.name,
        ),
        E(
            'Title',
            {
                'TitleType': 'DisplayTitle',
            },
            E('TitleText', track_metadata.name)
        ),
        *generate_track_display_artists(track_metadata),
        E(
            'ParentalWarningType',
            EXPLICIT_STATUS_LOOKUP_TABLE[track_metadata.explicit]
        ),
        E(
            'Genre',
            E('GenreText', track_metadata.product.subgenre.genre.name)
        )
    )


def _generate_all_release_details_by_territories(
    sound_recording_metadata: OrchardSoundRecording,
):
    # filter out tracks w/o territory claims
    claimed_tracks = [
        x for x in deduplicate_territories(sound_recording_metadata)
        if x.territories
    ]
    # generate territory blocks
    if claimed_tracks:
        return [
            _generate_release_details_by_territory(
                track.territories,
                track,
            )
            for track in claimed_tracks
        ]
    # handle "takedown"
    return [
        _generate_release_details_by_territory(
            [DEFAULT_TERRITORY_CODE],
            get_primary_track(sound_recording_metadata),
        )
    ]


def generate_release(
    release_reference: str,
    resource_reference: str,
    sound_recording_metadata: OrchardSoundRecording,
):
    """Generate a Release node."""
    primary_track_metadata = get_primary_track(sound_recording_metadata)
    return E(
        'Release',
        E(
            'ReleaseId',
            E('ISRC', primary_track_metadata.isrc),
        ),
        E('ReleaseReference', release_reference),
        generate_reference_title(primary_track_metadata),
        E(
            'ReleaseResourceReferenceList',
            E(
                'ReleaseResourceReference',
                {
                    'ReleaseResourceType': 'PrimaryResource',
                },
                resource_reference,
            ),
        ),
        E('ReleaseType', 'SingleResourceRelease'),
        *_generate_all_release_details_by_territories(
            sound_recording_metadata,
        ),
        *_generate_p_lines(sound_recording_metadata),
    )