"""Track logic."""
import logging

import const
from models import ows_product
from models import ows_track
import util # noqa
from utils import document as document_utils
from utils.profiling import measure_time
from utils.string import cleanup_unicode


def prepare_doc(event):
    """Construct a Cloudsearch document for the tracks corpus.

    Args:
        event (dict): event with track data from Mexwell's

    Returns:
        dict: cloudsearch document ready for upload

    """
    json_doc = {}
    doc_type = 'add'
    event_type = event.get('type')
    if not event_type or event.get('_metadata'):
        logging.warning(
            'An event with incompatible format received: %s',
            event)
        return json_doc

    if event_type == 'delete':
        doc_type = 'delete'

    track_id = event['data']['id']
    release_id = event['data']['release_id'] or 0

    if doc_type == 'add':
        with measure_time('get_track_artist_info'):
            track = ows_track.get_track_artist_info(track_id)
        with measure_time('get_release_info'):
            release = ows_product.get_release_info(release_id)
        # set defaults per data type
        json_doc = {
            'track_unique_id': track_id,
            'isrc': event['data']['isrc'] or '',
            'release_id': release_id,
            'track_name': cleanup_unicode(event['data']['track_name']) or '',
            'version': event['data']['version'] or '',
            'cd': event['data']['cd'] or 0,
            'track_id': event['data']['track_id'] or 0,
            'track_type': event['data']['track_type'] or '',
            'original_file_name': cleanup_unicode(
                event['data']['original_file_name']) or ''
        }
        json_doc.update(track)
        json_doc.update(release)
    if release_id in const.PRODUCT_EXCLUSION_LIST:
        # Delete the cloudsearch record for exclusion list
        doc_type = 'delete'

    return document_utils.prepare_for_upload(
        util.parse_spec_file('tracks'),
        {
            'type': doc_type,
            'id': f'track{track_id}',
            'fields': json_doc})


def prepare_release_tracks_docs(record_json):
    """Construct cloudsearch documents for the all tracks of the release for track corpus.

    Args:
        record_json (dict): record_json with release data from Mexwell's

    Returns:
        list of dicts: cloudsearch tracks documents ready for upload

    """
    doc_type = 'add'
    tracks_json_docs = []
    old_release_data = record_json['old']
    updated_release_data = record_json['data']
    release_id = updated_release_data['release_id']
    updated_release_status = updated_release_data.get('release_status')
    old_release_status = old_release_data.get('release_status')

    if (updated_release_status == const.STATUS_IN_CONTENT
            and old_release_status == const.STATUS_TRANSFER_TO_CONTENT):  # noqa
        with measure_time('get_all_tracks_by_product_id'):
            tracks = ows_track.get_all_tracks_by_product_id(release_id)
        if tracks:
            with measure_time('get_release_info'):
                release = ows_product.get_release_info(release_id)

        tracks_data = []
        for track in tracks:
            track_data = {
                'track_unique_id': track['tuid'],
                'release_id': release_id
            }
            track_data.update(track)
            track_data.update(release)
            tracks_data.append(track_data)

        for track_data in tracks_data:
            tracks_json_docs.append(
                document_utils.prepare_for_upload(
                    util.parse_spec_file('tracks'),
                    {
                        'type': doc_type,
                        'id': f'track{track_data["track_unique_id"]}',
                        'fields': track_data
                    }
                )
            )

    return tracks_json_docs