"""Track metadata model."""

import copy
from datetime import datetime

from ddtrace import tracer

from sound_recordings.connectors import dynamo, sentry
from sound_recordings.constants import cache
from sound_recordings.utils.cache import cache_in_redis

PRODUCT = "product"
TRACK_NUMBER = "track_number"
TRACK_CD = "track_cd"
IS_DELETED = "is_deleted"

TRACKS_PRODUCTS_LIMIT = 5


def _add_fallback_artists_list(track, products):
    """Add fall back artists list.

    If dim_sound_recording_artist isn't producing an artists fake
    the payload using release artist.
    """
    track_copy = copy.deepcopy(track)

    if not track.get("artists"):
        if products:
            product = products[0]
            release_artist = product.get("release_artist", "")
        else:
            release_artist = ""
            sentry.sentry_client.captureMessage(
                "[no product for track] "
                "Incorrect metadata items found for {}".format(track)
            )
        track_copy["artists"] = [{"artist_name": release_artist, "type": "performer"}]

        return track_copy

    return track_copy


def _patch_track(track):
    """Unpack nested objects from Dynamo track record into dictionaries.

    Args:
        track (dict): track from Dynamo

    Returns:
        dict: a dict which has been patched

    """
    track_copy = copy.deepcopy(track)
    track_copy["product"]["release_date"] = datetime.strptime(
        track_copy["product"]["release_date"], "%Y-%m-%d"
    ).date()
    track_copy["product"]["sales_start_date"] = datetime.strptime(
        track_copy["product"]["sales_start_date"], "%Y-%m-%d"
    ).date()
    track_copy["product"]["artists"] = [
        {"artist_name": track_copy["product"]["release_artist"], "type": "performer"}
    ]
    track_copy["artist_name"] = track_copy["product"]["release_artist"]
    return track_copy


def _patch_sound_recording(sound_recording):
    return _add_fallback_artists_list(sound_recording, sound_recording["products"])


def _is_not_deleted(item):
    return not (
        item.get(IS_DELETED, False) or item.get(PRODUCT, {}).get(IS_DELETED, False)
    )


@tracer.wrap(name="get_sound_recording_metadata")
@cache_in_redis(ttl=cache.SECONDS_PER_HOUR)
def get_track_metadata(permissions_filter, isrc, include_deleted=False):
    """Get metadata for an ISRC based on artist info ids.

    Args:
        permissions_filter (dict): dict containing resources users can access
        isrc (str): ISRC

    Returns:
        dict: track metadata

    """
    tracks = sorted(
        list(
            map(
                _patch_track,
                dynamo.query_by_range_key(
                    dynamo.create_track_key(isrc), permissions_filter=permissions_filter
                ),
            )
        ),
        key=lambda track: (_is_not_deleted(track), track["product"]["release_date"]),
        reverse=True,
    )

    sound_recording = next(iter(tracks), None)

    if not sound_recording:
        return None

    sound_recording["products"] = list(
        map(
            lambda track: track[PRODUCT],
            tracks if include_deleted else filter(_is_not_deleted, tracks),
        )
    )

    return _patch_sound_recording(sound_recording)