"""Artist Url logic."""

from oto import response
from oto import status

from social_analytics.constants import error
from social_analytics.logic import artist_search
from social_analytics.models import artist_url
from social_analytics.models import metric
from social_analytics.models import user_interaction


def get_last_viewed_artists(user_id):
    """Get last viewed artists for a user.

    Args:
        user_id (string): The user_id e.g. alw:123
    Returns:
        response.Response: containing a list of artist_ids, with the
        social_profiles and total followers for each artist_id.
    """
    user_interactions = user_interaction.get_user_interactions_by_user_id(
        user_id)

    if not user_interactions:
        return response.create_not_found_response()

    user_interactions = user_interactions.message['items']
    artist_ids = (
        [int(interaction['artist_id']) for interaction in user_interactions])

    artists_and_profiles = artist_url.get_social_profile_ids_by_artist_ids(
        artist_ids)

    if not artists_and_profiles:
        return response.create_not_found_response()

    artists_and_profiles = artists_and_profiles.message['items']

    social_profile_ids = _flatten_social_profile_ids(artists_and_profiles)

    metrics_response = metric.get_latest_metrics_by_social_profile_ids(
        social_profile_ids)

    if not metrics_response:
        return metrics_response

    metrics = metrics_response.message['items']

    # Each item has an artist id and a list of social profiles
    for artist_profiles in artists_and_profiles:
        social_profiles = artist_profiles['social_profiles']

        # For each social profile, a metric is returned
        for profile in social_profiles:
            profile_id = profile['social_profile_id']

            metric_value = list(
                filter(lambda x: x['social_profile_id'] == profile_id,
                       metrics))

            if not metric_value:
                continue

            profile['metric'] = metric_value[0]['metric']
            profile['metric_value'] = metric_value[0]['metric_value']
            profile['platform'] = metric_value[0]['platform']

    return response.Response({'items': artists_and_profiles})


def _flatten_social_profile_ids(artist_and_social_profiles):
    """Flatten social profile ids.

    Args:
        artist_and_social_profiles (list): A list containing artist_ids and
            for each artist id a list with its related social_profiles.
    Returns:
        list: a list with all the social_profile_ids
    """
    social_profile_ids = []
    for artist_profiles in artist_and_social_profiles:
        social_profiles = artist_profiles['social_profiles']
        ids = [profile['social_profile_id'] for profile in social_profiles]
        social_profile_ids.extend(ids)

    return social_profile_ids


def delete_social_profile(social_profile_id, artist_id):
    """Delete an artist url reference to an artist id.

    Args:
        social_profile_id (int): The social_profile_id.
        artist_id (int): The artist_id.
    Returns:
        response.Response: containing the deleted artist social profile dict,
        not found if no profile was deleted or Bad Params.
    """
    return artist_url.clear_social_profile(social_profile_id, artist_id)


def search_artists(params, headers):
    """Get the artist urls under a label id and artist id.

    Args:
         params (dict): A dict containing the following params:
            {
                'context',
                'token',
                'term'
            }
        headers (dict) : The Grass headers to be passed to ows-search
    Returns:
        response.Response: Containing a list with all the artist social
            profiles.
    """
    artists_response = artist_search.search_artist(params, headers)

    if not artists_response:
        return artists_response

    artists = artists_response.message['items']
    artist_ids = [int(artist['artist_id']) for artist in artists]

    if not artist_ids:
        return response.create_not_found_response()

    ids_with_profiles_response = (
        artist_url.get_artist_ids_that_have_profiles(artist_ids))

    if not ids_with_profiles_response:
        return ids_with_profiles_response

    ids = ids_with_profiles_response.message['items']

    results = []
    for artist in artists:
        artist_id = int(artist['artist_id'])
        item = {
            'artist_id': artist_id,
            'artist_name': artist['artist_name'],
            'is_linked': artist_id in ids
        }
        results.append(item)

    return response.Response({'items': results})


def migrate_artist_social_profile_to_artist_url(data):
    """Migrate artist social profile to artist url schema.

    Args:
        data (dict): Dictionary with information about social_profile and
        artist_social_profile.
    Returns:
        response.Response: Containing a list with all the artist social
            profiles.
    """
    if not data:
        return response.create_error_response(
            status.BAD_REQUEST, error.ERROR_MESSAGE_EMPTY_BODY)

    artist_id = data['artist_id']
    social_profile_id = data['social_profile_id']
    evaluated_for_collection = True

    if data['platform'] == 'facebook':
        site_id = 2
        url = data['platform_id']
    if data['platform'] == 'instagram':
        site_id = 46
        url = data['platform_name']
    if data['platform'] == 'spotify':
        site_id = 47
        url = data['platform_id']

    found_artist_url = artist_url.get_artist_url_with_artist_id_and_site_id(
        artist_id, site_id)

    if not found_artist_url:
        data_to_create_new_artist_url = {
            'site_id': site_id,
            'artist_id': artist_id,
            'url': url,
            'social_profile_id': social_profile_id,
            'evaluated_for_collection': evaluated_for_collection}

        return artist_url.create_artist_url(data_to_create_new_artist_url)
    else:
        found_artist_url_as_dict = found_artist_url.message
        url_id = found_artist_url_as_dict['url_id']

        data_to_update_artist_url = {
            'url_id': url_id,
            'site_id': site_id,
            'artist_id': artist_id,
            'url': url,
            'social_profile_id': social_profile_id,
            'evaluated_for_collection': evaluated_for_collection}

        return artist_url.update_artist_url(data_to_update_artist_url)