"""Participant Handlers."""
from switchboard_consumer.constants import system
from switchboard_consumer.constants.exceptions import ParticipantHandlerError
from switchboard_consumer.constants.video_product_roles import \
    VIDEO_SINGLE_COMPOUND_ROLES, VIDEO_TRACK_CONTRIBUTOR_ROLE_MAPPING
from switchboard_consumer.logic.participant.base_participant_handler \
    import BaseParticipantHandler
from switchboard_consumer.utils.message import get_system_local_id


class VideoSingleParticipantHandler(BaseParticipantHandler):
    """Handle participants for VIDEO_SINGLE product track."""

    def __init__(
            self,
            logger,
            orchard_client,
            message,
            product_data,
            vendor_id,
            subaccount_id):
        """Create a ProductParticipantHandler instance.

        Args:
            logger: Logger instance
            orchard_client: OrchardClient instance
            message: Incoming KafkaMessage
            vendor_id: target vendor id
            subaccount_id: target subaccount id
        """
        super().__init__(logger, orchard_client, message, vendor_id,
                         subaccount_id)
        self.product_data = product_data
        self.participants = []
        self.processing_results = []

    def process(self):
        """Process video single participants."""
        first_side = self.product_data['components'][0]['sides'][0]
        track_data = first_side['productTracks'][0]['track']

        # collecting performers from video single track
        track_display_artists = track_data['displayArtists']
        processed_track_primary_artists = self._process_track_display_artists(
            track_display_artists)
        self._extend_results(processed_track_primary_artists)

        # collecting performer from video single product
        product_display_artist = self.product_data['displayArtist']
        processed_product_primary_artist = (
            self._process_product_display_artist(product_display_artist))
        self._extend_results(processed_product_primary_artist)

        # collecting production roles from video single track
        track_contributors = track_data['contributors']
        processed_track_contributors = self._process_contributors(
            track_contributors)
        self._extend_results(processed_track_contributors)

        # collecting production roles from video single product
        product_contributors = self.product_data['contributors']
        processed_product_contributors = (
            self._process_contributors(product_contributors))
        self._extend_results(processed_product_contributors)

        return (self.processing_results, self.participants)

    def _extend_results(
            self, processed_items):
        for processing_result, participant in processed_items:
            # We do not need to include empty processing results.
            if processing_result:
                self.processing_results.append(processing_result)
            # We do not need to include duplicate participants.
            if participant not in self.participants:
                self.participants.append(participant)

    @classmethod
    def _get_mapping(cls, participant):
        source_mapping = get_system_local_id(
            participant, system.SONY)
        target_mapping = get_system_local_id(participant)
        return source_mapping, target_mapping

    def _process_track_display_artists(self, display_artists):
        participants_to_process = []
        for display_artist in display_artists:
            participant = display_artist['participant']
            if self._is_compound_participant(participant):
                for member in participant['members']:
                    participants_to_process.append(member['participant'])
            else:
                participants_to_process.append(participant)

        handled_display_artists = []
        for participant in participants_to_process:
            role = 'performer'

            source_mapping, target_mapping = self._get_mapping(participant)
            handled_display_artist = self.handle_participant(
                participant, role, source_mapping,
                target_mapping)
            handled_display_artists.append(handled_display_artist)
        return handled_display_artists

    def _process_track_compound_participant(
            self, compound_participant, parent_participant_role):
        handled_members = []
        for member in compound_participant['members']:
            member_source_role = member['role']
            member_participant = member['participant']

            if member_source_role == 'Primary':
                member_target_role = parent_participant_role
            elif member_source_role in ('Featured', 'With'):
                member_target_role = 'featuring'
            else:
                msg = 'Failed to map role {} for compound participant'.format(
                    member_source_role)
                raise ParticipantHandlerError(msg)

            source_mapping, target_mapping = self._get_mapping(
                member_participant)
            handled_member = self.handle_participant(
                member_participant, member_target_role,
                source_mapping, target_mapping)
            handled_members.append(handled_member)

        return handled_members

    def _process_contributors(self, contributors):
        handled_contributors = []
        for contributor in contributors:
            participant = contributor['participant']
            source_role = contributor['role']
            if VIDEO_TRACK_CONTRIBUTOR_ROLE_MAPPING.get(source_role):
                target_role = VIDEO_TRACK_CONTRIBUTOR_ROLE_MAPPING[source_role]
                if self._is_compound_participant(participant):
                    handled_contributors += (
                        self._process_track_compound_participant(
                            participant, target_role))
                else:
                    source_mapping, target_mapping = self._get_mapping(
                        participant)
                    handled_contributor = self.handle_participant(
                        participant, target_role,
                        source_mapping, target_mapping)
                    handled_contributors.append(handled_contributor)
        return handled_contributors

    def _process_product_display_artist(self, product_display_artist):
        participants_to_process = []
        if self._is_compound_participant(product_display_artist):
            for member in product_display_artist['members']:
                participants_to_process.append(member['participant'])
        else:
            participants_to_process.append(product_display_artist)

        handled_display_artists = []
        for participant in participants_to_process:
            role = 'performer'

            source_mapping, target_mapping = self._get_mapping(participant)

            handled_display_artist = self.handle_participant(
                participant, role, source_mapping, target_mapping)
            handled_display_artists.append(handled_display_artist)
        return handled_display_artists

    @classmethod
    def _is_compound_participant(cls, participant):
        members = participant.get('members', [])
        if not members:
            return False
        member_roles = [member['role'] for member in members]
        for role in member_roles:
            if role not in VIDEO_SINGLE_COMPOUND_ROLES:
                return False
        return True