"""Formatters for video single products."""
from switchboard_consumer.constants.languages import LANGUAGE_MAPPING
from switchboard_consumer.constants.video_single_type import VIDEO_TYPE_MAPPING
from switchboard_consumer.formatters.common import format_title_fields
from switchboard_consumer.formatters.product import (
    format_cline, format_genres, format_imprint, format_not_for_distribution,
    format_pline, format_special_instructions, get_company_code)
from switchboard_consumer.utils.message import get_system_local_id


def format_type_of_video(swb_type_of_video):
    """Map SWB format_type to Orchard."""
    return VIDEO_TYPE_MAPPING.get(swb_type_of_video, None)


def _parse_explicit(parental_warning_type):
    """Parse parentalWarningType field."""
    parental_warning_type_mapping = {
        'EXPLICIT': 'Yes',
        'NOT_EXPLICIT': 'No',
        'EXPLICIT_CONTENT_EDITED': 'Clean Version'
    }
    return parental_warning_type_mapping.get(parental_warning_type, '')


def _get_language_of_video_title(product, track):
    key = None
    if product.get('metaLanguage'):
        key = product.get('metaLanguage')
    elif track.get('metaLanguage'):
        key = track.get('metaLanguage')

    if key:
        return LANGUAGE_MAPPING.get(key.upper())
    return None


def _format_channel_selection(product):
    """Format VEVO channel."""
    if product.get('channelSet'):
        return product['channelSet'][0]['channelCode']
    return None


def _get_associated_track_id(track_data):
    """Extract associated audio track id."""
    related_track_data = track_data['relatedAudioTrack']
    if related_track_data:
        orchard_local_id = get_system_local_id(related_track_data)
        if orchard_local_id:
            return int(orchard_local_id['localId'])
    return None


def format_video_single_create_input(product_data, artists):
    """Format video single product create for graphql-product."""
    first_side = product_data['components'][0]['sides'][0]
    track = first_side['productTracks'][0]['track']
    formal_title_text, formal_title_subtitle = format_title_fields(
        product_data)
    genre_id, subgenre_id = format_genres(product_data)
    pline = format_pline(product_data)
    cline = format_cline(product_data)
    if not pline:
        pline = cline
    c_line_year, c_line_holder = cline.split(' ', 1)
    p_line_year, p_line_holder = pline.split(' ', 1)
    orchard_id = get_system_local_id(product_data['project'])
    language_of_video_title = _get_language_of_video_title(
        product_data, track)
    language_of_video_content = None
    if track.get('languageOfPerformance'):
        language_of_video_content = LANGUAGE_MAPPING.get(
            track.get('languageOfPerformance').upper())
    return {
        'projectId': orchard_id['localId'],
        'typeOfVideo': format_type_of_video(track['videoType']),
        'associatedTrackId': _get_associated_track_id(track),
        'videoTitle': formal_title_text,
        'languageOfVideoTitle': language_of_video_title,
        'primaryArtists': artists,
        'imprint': format_imprint(product_data),
        'isrc': track['isrc'],
        'upc': product_data['upc'],
        'productCode': product_data['catalogNumber'],
        'languageOfVideoContent': language_of_video_content,
        'genreId': genre_id,
        'subgenreId': subgenre_id,
        'parentalAdvisory': _parse_explicit(track['parentalWarningType']),
        'clineYear': int(c_line_year),
        'clineCopyrightHolder': c_line_holder,
        'plineYear': int(p_line_year),
        'plineCopyrightHolder': p_line_holder,
        'version': formal_title_subtitle,
        'description': product_data['description'],
        'lyrics': track['lyrics'],
        'accountId': int(product_data['labelAccount']['companyCode']),
        'subaccountId': get_company_code(product_data.get('subAccount', None)),
        'specialInstructions': format_special_instructions(product_data),
        'channelSelection': _format_channel_selection(product_data),
        'notForDistribution': format_not_for_distribution(product_data)
    }


def format_video_single_update_input(product_data, artists):
    """Format video single product update for graphql-product."""
    payload = format_video_single_create_input(product_data, artists)
    fields_to_remove = [
        'isrc',
        'productCode',
        'projectId',
        'upc'
    ]
    for field_to_remove in fields_to_remove:
        payload.pop(field_to_remove)
    orchard_product_id = get_system_local_id(product_data)
    payload['productId'] = orchard_product_id['localId']
    return payload