"""Utility Functions for products."""
from collections import defaultdict

from backend.constants import artist_role
from backend.constants import corrections as correction_consts
from backend.constants import product as product_consts


def is_in_correction_mode(digital_product):
    """Determine if digital product is in correction mode.

    Args:
        digital_product (dict): Digital Product dictionary

    Returns:
        bool
    """
    if digital_product.get(product_consts.RELEASE_STATUS) == product_consts.IS_ERR_CORR_MODE:
        return True
    if digital_product.get(product_consts.IS_ERR_CORR_ACTN_REQ_MODE):
        return True
    if get_digital_product_corrections_status(digital_product) == correction_consts.STATUS_SUBMITTED:
        return True
    return False


def get_digital_product_corrections(digital_product):
    """Get list of product corrections.

    Args:
        digital_product (dict): Digital product dictionary

    Returns:
        Array
    """
    return digital_product.get('corrections', {}).get('items', [])


def get_digital_product_corrections_status(digital_product):
    """Get list of product corrections.

    Args:
        digital_product (dict): Digital product dictionary

    Returns:
        Array
    """
    return digital_product.get('corrections', {}).get('status', None)


def map_correction_field_name_to_track_field_name(field_name):
    """Convert correction field name to track field name.

    Args:
        field_name (str): Name of digital product property.

    Returns:
        str
    """
    return {
        'explicit_lyrics': 'explicit',
        'meta_language': 'meta_language_code',
        'p_line': 'p_info',
        'track_artist': 'primary_artist',
        'track_writer': 'writers'
    }.get(field_name, field_name)


def get_track_corrections(digital_product):
    """Get track corrections grouped by track id.

    Args:
        digital_product (dict): Digital product dictionary.

    Returns:
        dictionary
    """
    product_corrections = get_digital_product_corrections(digital_product)
    track_corrections = defaultdict(dict)
    for correction in product_corrections:
        if correction['table_name'] == 'track':
            track_id = correction['key_id']
            field_name = map_correction_field_name_to_track_field_name(
                correction['field_name']
            )
            key_value = correction['key_value']
            if field_name == 'primary_artist':
                primary_artists, ensembles, conductors, orchestras, composers = [], [], [], [], []
                
                for artist in key_value:
                    if artist.get('type') == artist_role.COMPOSER:
                        composers.append(artist)
                    elif artist.get('type') == artist_role.ORCHESTRA:
                        orchestras.append(artist)
                    elif artist.get('type') == artist_role.CONDUCTOR:
                        conductors.append(artist)
                    elif artist.get('type') == artist_role.ENSEMBLE:
                        ensembles.append(artist)
                    else:
                        primary_artists.append(artist)
                
                if composers or orchestras or conductors or ensembles:
                    # These are all saved every time in workstation, adding an error correction for 1 value makes an
                    # ec for all 4. Removing one in ec just removes it from the list, so that should be represented 
                    # as an [] here.
                    track_corrections[track_id][artist_role.COMPOSER] = composers
                    track_corrections[track_id][artist_role.ORCHESTRA] = orchestras
                    track_corrections[track_id][artist_role.CONDUCTOR] = conductors
                    track_corrections[track_id][artist_role.ENSEMBLE] = ensembles
                
                # Add other artists to 'primary_artist' field 
                # or if primary_artist key existed with an empty list (no artist) add that
                track_corrections[track_id]['primary_artist'] = primary_artists
            else:
                track_corrections[track_id][field_name] = key_value
    return track_corrections


def get_product_metalanguage_correction(digital_product):
    """Get product meta language corrections grouped by product id.

    Args:
        digital_product (dict): Digital product dictionary.

    Returns:
        dictionary
    """
    product_corrections = get_digital_product_corrections(digital_product)
    language_corrections = defaultdict(dict)
    if product_corrections:
        for correction in product_corrections:
            if correction['table_name'] == 'releases' \
                    and correction['field_name'] == 'meta_language':
                product_id = correction['key_id']
                field_name = correction['field_name']
                language_corrections[product_id][field_name] = \
                    correction['key_value']
    return language_corrections


def get_product_name_correction(digital_product):
    """Get product the name correction.

    Args:
        digital_product (dict): Digital product dictionary.

    Returns:
        string or None
    """
    product_corrections = get_digital_product_corrections(digital_product)
    name_correction = None
    if product_corrections:
        for correction in product_corrections:
            if correction['table_name'] == 'releases' \
                    and correction['field_name'] == 'release_name':
                name_correction = correction['key_value']
    return name_correction


def get_product_version_correction(digital_product):
    """Get product the version correction.

    Args:
        digital_product (dict): Digital product dictionary.

    Returns:
        string or None
    """
    product_corrections = get_digital_product_corrections(digital_product)
    version_correction = None
    if product_corrections:
        for correction in product_corrections:
            if correction['table_name'] == 'releases' \
                    and correction['field_name'] == 'delivered_version':
                version_correction = correction['key_value']
    return version_correction


def get_product_imprint_correction(digital_product):
    """Get product the imprint correction.

    Args:
        digital_product (dict): Digital product dictionary.

    Returns:
        string or None
    """
    product_corrections = get_digital_product_corrections(digital_product)
    imprint_correction = None
    if product_corrections:
        for correction in product_corrections:
            if correction['table_name'] == 'releases' \
                    and correction['field_name'] == 'label':
                imprint_correction = correction['key_value']
    return imprint_correction


def get_product_featuring_artist_corrections(digital_product):
    """Get product featuring artist corrections grouped by product id.

    Args:
        digital_product (dict): Digital product dictionary.

    Returns:
        dictionary
    """
    product_corrections = get_digital_product_corrections(digital_product)
    featuring_artist_corrections = defaultdict(dict)
    if product_corrections:
        for correction in product_corrections:
            if correction['table_name'] == 'releases' \
                    and correction['field_name'] == 'featuring':
                product_id = correction['key_id']
                field_name = correction['field_name']
                featuring_artist_corrections[product_id][field_name] = \
                    correction['key_value']
    return featuring_artist_corrections

def get_product_primary_artist_corrections(digital_product):
    """Get product primary artist corrections grouped by product id.

    Args:
        digital_product (dict): Digital product dictionary.

    Returns:
        dictionary
    """
    product_corrections = get_digital_product_corrections(digital_product)
    primary_artist_corrections = defaultdict(dict)
    if product_corrections:
        for correction in product_corrections:
            if correction['table_name'] == 'releases' \
                    and correction['field_name'] == 'performer':
                product_id = correction['key_id']
                field_name = correction['field_name']
                primary_artist_corrections[product_id][field_name] = \
                    correction['key_value']
    return primary_artist_corrections


def get_product_artist_corrections_for_key(key, digital_product):
    """Get product artist corrections grouped by product id.

    Args:
        key (str): artist type key
        digital_product (dict): Digital product dictionary.

    Returns:
        dictionary
    """
    product_corrections = get_digital_product_corrections(digital_product)
    artist_corrections = defaultdict(dict)
    if product_corrections:
        for correction in product_corrections:
            if correction['table_name'] == 'releases' \
                    and correction['field_name'] == key:
                product_id = correction['key_id']
                field_name = correction['field_name']
                artist_corrections[product_id][field_name] = \
                    correction['key_value']
    return artist_corrections    


def get_product_artist_correction_names(artist_corrections, product_id):
    """Get names of artists (primary or featuring) from a list of corrections for a particular product.

    Args:
        artist_corrections (list): product level artist corrections.
        product_id (int): Product id

    Returns:
        list
    """
    product_artists = []
    if type(artist_corrections) is defaultdict:
        artist_data = artist_corrections.get(product_id, {})
        for artist_key, artist_value in artist_data.items():
            for artist in artist_value:
                if 'artist_name' in artist:
                    product_artists.append(artist['artist_name'])
                if 'name' in artist:
                    product_artists.append(artist['name'])
    return product_artists


def get_featuring_artists(artists, category):
    """Get featuring artists from a list of artists.

    Args:
        artists (list): Artists from track or product level.
        category (str): 'type' if track level, 'role' if product level.

    Returns:
        list
    """
    featuring_artists = []
    for artist in artists:
        if artist[category] == 'featuring':
            featuring_artists.append(artist['name'])
    return featuring_artists


def get_primary_artists(artists, category):
    """Get primary artists from a list of artists.

    Args:
        artists (list): Artists from track or product level.
        category (str): 'type' if track level, 'role' if product level.

    Returns:
        list
    """
    arttype = 'primary_artist' if category == 'role' else 'performer'
    primary_artists = []
    for artist in artists:
        if artist[category] == arttype:
            primary_artists.append(artist['name'])
    return primary_artists


def get_artists_by_key(key, artists, category):
    """Get artists from a list of artists that match the key.

    Args:
        key (str): artist type key
        artists (list): Artists from track or product level.
        category (str): 'type' if track level, 'role' if product level.

    Returns:
        list
    """
    artists_by_key = []
    for artist in artists:
        if artist[category] == key:
            artists_by_key.append(artist['name'])
    return artists_by_key