"""Functions specific to phonofile_ingestor."""
import json

import integration_scripts.general_use as general_use


def slice_off_request_code(d):
    """Comprehension to slice off request_code."""
    return {i: j for i, j in d.items() if i != 'release_code'}


def get_response_data(response):
    """Get the data from a response object's json."""
    try:
        if 'error' in response:
            return response
    except TypeError:
        pass

    try:
        response_data_obj = json.loads(response.text)
    except ValueError as e:
        return {
            'error': {
                'msg': 'Malformed response',
                'bad_response': response.text,
                'exception': str(e)
            }
        }

    if 'error' in response_data_obj:
        return response_data_obj

    return response_data_obj['envelope']['response']


def process_track_params(release_dict, params):
    """Create log entries for tracks in the track log."""
    return_list = list()

    # Same as release
    release_params_dict = dict()
    release_params_dict['orchard_vendor_id'] = params['orchard_vendor_id']
    release_params_dict['session_id'] = params['session_id']
    release_params_dict['request_num'] = params['request_num']
    release_params_dict['product_code'] = params['product_code']
    release_params_dict['project_code'] = params['project_code']

    # track_params_dict = dict()
    # create track rows
    for error_key, error_list in release_dict.items():
        if error_key != 'data':
            track_params_dict = dict()
            vol_track_row = error_key.split('_')

            track_params_dict['errors'] = list()

            if not general_use.represents_int(vol_track_row[0]):
                # General
                track_params_dict['vol_num'] = 0
                track_params_dict['track_num'] = 0
            else:
                # Track specific
                track_params_dict['vol_num'] = vol_track_row[0]
                track_params_dict['track_num'] = vol_track_row[1]

            # Build error list
            for error_name, error_msg in error_list.items():
                track_params_dict['errors'].append(
                    '{} - {}'.format(
                        error_name, json.dumps(error_msg, ensure_ascii=True)))

            # track_params_dict['errors'] = track_params_dict['errors']

            return_list.append(
                general_use.merge_two_dicts(release_params_dict,
                                            track_params_dict))

    return return_list


def mark_all_tracks(status, params, track_and_vol_count):
    """Mark all tracks as 'Updated' or 'New' depending on the passed vars."""
    return_list = list()

    # Same as release
    release_params_dict = dict()
    release_params_dict['orchard_vendor_id'] = params['orchard_vendor_id']
    release_params_dict['session_id'] = params['session_id']
    release_params_dict['request_num'] = params['request_num']
    release_params_dict['product_code'] = params['product_code']
    release_params_dict['project_code'] = params['project_code']

    for vol, tracks in track_and_vol_count.items():
        for n in range(tracks):
            track_item = {
                'errors': [
                    'No Error - Release is {}.'.format(status.capitalize())
                ],
                'vol_num': vol,
                'track_num': n + 1
            }

            return_list.append(
                general_use.merge_two_dicts(release_params_dict, track_item))

    return return_list


def create_bulk_upload_response_log(
        data, label_params, is_requeue, track_and_vol_count):
    """Create the entire response log for a single release."""
    release_params = list()
    track_params = list()
    params = dict()

    for action_type, releases in data.items():
        # Error list - often empty
        if type(releases) is list:
            if len(releases):
                params['response'] = releases
                params['action_type'] = 'misc error list'
                if is_requeue:
                    params['action_type'] += ' - is_requeue'
                release_params.append(
                    general_use.merge_two_dicts(label_params, params))
                params = dict()

        # Release-level responses
        elif type(releases) is dict:
            for key, release in releases.items():
                project_code, product_code = key.split('_____')

                params['product_code'] = product_code
                params['project_code'] = project_code

                if action_type == 'updated_releases':
                    params['action_type'] = 'release updated'
                    if is_requeue:
                        params['action_type'] += ' - requeue'
                    params['release_id'] = release['release_id']
                    params['project_id'] = release['project_id']

                    merged_dict = general_use.merge_two_dicts(
                        label_params, params)

                    track_params.append(mark_all_tracks(
                        'updated', merged_dict, track_and_vol_count))

                elif action_type == 'error':
                    params['action_type'] = 'ingestion failed - track errors'
                    if is_requeue:
                        params['action_type'] += ' - requeue'
                    params['release_id'] = None
                    # params['project_id'] = None

                    # Merge action type and release_id into release params
                    merged_dict = general_use.merge_two_dicts(
                        label_params, params)

                    # Format track-level error log params
                    track_params.append(
                        process_track_params(release, merged_dict))

                elif action_type == 'new_releases':
                    params['action_type'] = 'new release created'
                    if is_requeue:
                        params['action_type'] += ' - requeue'
                    params['release_id'] = release['release_id']
                    params['project_id'] = release['project_id']

                    merged_dict = general_use.merge_two_dicts(
                        label_params, params)

                    track_params.append(mark_all_tracks(
                        'new', merged_dict, track_and_vol_count))
                else:
                    params['action_type'] = 'unknown'
                    if is_requeue:
                        params['action_type'] += ' - requeue'

                params['response'] = release

                release_params.append(
                    general_use.merge_two_dicts(label_params, params))

                params = dict()

    return release_params, track_params