"""Validation Formatting Logic."""
import json

from oto import response

from product_digital.constants.product import ValidationType


def format_as_list(validations):
    """Format validations as list."""
    if not validations.message:
        return validations
    return response.Response(
        message={'validations': format_validations_as_list(validations.message.get('validations'))})


def _format_validation(code, reason):
    return {'code': code.upper(), 'reason': reason}


def format_validations_as_list(validations):
    """Format the response from the validation endpoint into a list of validations."""
    errors = []
    warnings = []
    is_valid = True
    tracks = {}
    for group, data in validations.items():
        if data.get('valid', True) is False and group != ValidationType.PRODUCT_BLOCKLIST:
            is_valid = False
        if group == ValidationType.ARTWORK:
            if data['valid'] is False:
                errors.append(_format_validation('ARTWORK', ''.join(data['errors'])))
        elif group == ValidationType.PRODUCT_BLOCKLIST:
            for err in data['errors']:
                warnings.append(_format_validation('BLOCKLIST', json.dumps(err)))
        elif group == ValidationType.TRACKS:
            _format_track_validations(data, tracks)
        elif group == ValidationType.PUBLISHING_OBLIGATION:
            _format_publishing_validations(data, tracks)
        elif group == ValidationType.ACCOUNT:
            for err in data['errors']:
                errors.append(_format_validation(err['code'], err.get('reason')))
        else:
            if isinstance(data['errors'], dict):
                # errors is either a dict or an array
                for err in data['errors'].values():
                    errors.append(_format_validation(err['error_code'], err.get('message')))
            else:
                for err in data['errors']:
                    errors.append(_format_validation(err['error_code'], err.get('message')))
            if 'warnings' in data:
                for warning in data['warnings']:
                    warnings.append(_format_validation(warning.get('code'), warning.get('reason')))

    return {'is_valid': is_valid, 'errors': errors, 'warnings': warnings, 'tracks': tracks}


def _format_track_validations(data, tracks):
    for track_errs in data['errors']:
        tuid = str(track_errs['tuid'])
        _initialize_track_data(tracks, tuid)
        for key, track_err in track_errs.items():
            if key == 'localizations':
                tracks[tuid]['is_valid'] = False
                for loc_err in track_err:
                    tracks[tuid]['errors'].append(_format_validation(loc_err['error_code'], loc_err['message']))
            elif key != 'tuid':
                tracks[tuid]['is_valid'] = False
                tracks[tuid]['errors'].append(_format_validation(track_err['error_code'], track_err['message']))
    for track_warn in data.get('warnings', []):
        tuid = str(track_warn['tuid'])
        _initialize_track_data(tracks, tuid)
        for key, data in track_warn.items():
            if key != 'tuid':
                tracks[tuid]['warnings'].append(_format_validation(data['code'], data['message']))


def _format_publishing_validations(data, tracks):
    for track_errs in data['errors']:
        tuid = str(track_errs['tuid'])
        _initialize_track_data(tracks, tuid)
        for key, data in track_errs.items():
            if key != 'tuid':
                tracks[tuid]['is_valid'] = False
                tracks[tuid]['errors'].append(_format_validation(data['error_code'], data['message']))


def _initialize_track_data(tracks, tuid):
    if tuid not in tracks:
        tracks[tuid] = {
            'tuid': int(tuid),
            'is_valid': True,
            'errors': [],
            'warnings': []
        }