"""Logic for formatting data."""

from datetime import datetime

from src.constants import error_correction_field as ec
from src.constants import track_field as tf
from src .constants import track_role as tr
from src.logic.track_role import _include_existing_track_role_fields


def _format_basic_fields(data, final_result):
    """Format basic track field corrections."""
    result = {}
    for ec_field_key, val in data.items():
        tf_key = None
        if ec_field_key in ec.BASIC_FIELD_MAP:
            tf_key = ec.BASIC_FIELD_MAP[ec_field_key]
        elif ec_field_key in tf.BASIC_MODEL_FIELDS:
            tf_key = ec_field_key

        if not tf_key:
            continue

        if not val:
            result[tf_key] = val
        elif tf_key in tf.NUMERIC_FIELDS:
            result[tf_key] = int(val)
        elif tf_key in tf.STRING_FIELDS:
            result[tf_key] = str(val)
        elif tf_key in tf.DATE_FIELDS:
            result[tf_key] = datetime.strptime(val, '%Y-%m-%d').date()
        else:
            result[tf_key] = val

    final_result.update(result)


def _format_track_artist_fields(data, final_result):
    """Format corrections on track artist role fields."""
    corrections = []
    entry_types = set()
    for field_name, key_value in data.items():
        fn = tr.FEATURE_TO_PRIMARY if field_name == ec.FEATURE_TO_PRIMARY else field_name
        if fn != ec.TRACK_ARTIST and fn not in tr.SUPPORTED_ARTIST_ROLES:
            continue
        entry_types.add(fn)
        for k in key_value:
            entry_types.add(k['type'])
        corrections = corrections + key_value
    if len(entry_types):
        current_data = list(filter(
            lambda x: (x['type'] in tr.SUPPORTED_ARTIST_ROLES and
                       x['type'] not in entry_types),
            data.get(f'{tf.ARTISTS}_tag', [])
        ))
        final_result[tf.ARTISTS] = [*corrections, *current_data]


def _format_track_writers(data, final_result):
    """Format track writers field."""
    track_writer_corrections = data.get(ec.TRACK_WRITER, None)
    if track_writer_corrections is None:
        return
    update_data = list(map(
        lambda name: {'type': tr.WRITER, 'name': name}, track_writer_corrections))
    final_result[tf.WRITERS] = update_data


def format_track_correction_data(data):
    """Format track correction data."""
    result = {}
    relevant_data = dict(filter(lambda x: x[0] not in ec.NOT_FOR_UPDATE, data.items()))
    _format_basic_fields(relevant_data, result)
    _format_track_artist_fields(relevant_data, result)
    _format_track_writers(relevant_data, result)
    return result


def structure_corrections_by_tuid(track_revisions):
    """Structure corrections by tuid."""
    grouped_by_tuid = {}
    for item in track_revisions:
        tuid = str(item['key_id'])
        if tuid not in grouped_by_tuid:
            grouped_by_tuid[tuid] = {}
        grouped_by_tuid[tuid][item['field_name']] = item['key_value']
    _include_existing_track_role_fields(grouped_by_tuid)
    return grouped_by_tuid


def remove_track_duration(formatted_data):
    """Remove track duration."""
    result = {}
    for key in tf.DURATION_FIELDS:
        if key in formatted_data:
            result[key] = formatted_data.pop(key)
    return result