"""Project metadata update."""
import json

from switchboard_consumer.constants.exceptions import (
    ParticipantHandlerError,
    ParticipantHandlerGraphQLError
)
from switchboard_consumer.constants.system import SONY
from switchboard_consumer.formatters.errors import (format_exception,
                                                    format_graphql_errors)
from switchboard_consumer.formatters.product import get_company_code
from switchboard_consumer.\
    logic.participant.project_participant_handler import (
        ProjectParticipantHandler
    )
from switchboard_consumer.logic.project import \
    create_project, update_project, validate_project
from switchboard_consumer.utils.graphql import is_error
from switchboard_consumer.utils.message import (create_processing_result,
                                                get_system_local_id)


def handle_project_metadata_update(logger, message, swb_client,
                                   orchard_client):
    """Handle a PROJECT:METADATA_UPDATES message."""
    results = []

    original_id = message.sending_system_local_id

    data = swb_client.lookup_project_by_local_id(original_id,
                                                 message.correlation_id)

    if data.get('errors'):
        errors = data.get('errors')
        logger.error('Error looking up project by localId: {} - {}'
                     .format(original_id, errors))

        results.append(create_processing_result(
            message.ids,
            message,
            errors=format_graphql_errors(errors))
        )
        return results

    validation_errors = validate_project(message, data)
    if validation_errors:
        results.extend(validation_errors)
        return results

    orchard_id = get_system_local_id(data)

    # Attempt to lookup the Orchard Project by Sony Local Id
    vendor_id = get_company_code(data['labelAccount'])
    subaccount_id = get_company_code(data['subAccount'])

    project_participant_handler = ProjectParticipantHandler(
        logger,
        orchard_client,
        message,
        vendor_id,
        subaccount_id
    )

    try:
        result, artist = project_participant_handler.process(
            data
        )
        if result:
            results.append(result)
    except ParticipantHandlerGraphQLError as e:
        # We encountered a GraphQL error setting up participants
        logger.error('Error encountered handling Project participant',
                     custom_fields={'raw_errors': e})
        results.append(create_processing_result(
            message.ids, message, errors=e.raw_errors))
        return results
    except ParticipantHandlerError as e:
        # We raised a handler error
        logger.error('Error encountered handling Project participant',
                     custom_fields={'raw_errors': e})
        results.append(create_processing_result(
            message.ids, message, exception=format_exception(e)))
        return results

    orchard_local_id = None
    sony_local_id = get_system_local_id(data, SONY)['localId']

    if orchard_id:
        orchard_local_id = int(orchard_id['localId'])
    else:
        orchard_project_response = orchard_client.get_project_by_project_code(
            sony_local_id, vendor_id, subaccount_id, message.correlation_id)
        if is_error(orchard_project_response):
            logger.error('Error occured looking up Orchard Project',
                         custom_fields={
                             'lookup_project_code': sony_local_id,
                             'vendor_id': vendor_id,
                             'subaccount_id': subaccount_id,
                             'raw_error': json.dumps(
                                 orchard_project_response['errors'])})
            results.append(create_processing_result(
                message.ids, message, errors=format_graphql_errors(
                    orchard_project_response['errors'])))
            return results
        try:
            orchard_local_id = int(orchard_project_response['projectId'])
            logger.info('Found existing Project via Project Code Lookup',
                        custom_fields={
                            'lookup_project_code': sony_local_id,
                            'vendor_id': vendor_id,
                            'subaccount_id': subaccount_id,
                            'found_project_id': orchard_local_id
                        }
                        )
        except (KeyError, TypeError):
            pass

    if orchard_local_id:
        # Update existing project.
        update_data = {
            'projectId': orchard_local_id,
            'name': data['name'],
            'artistId': artist['artistInfoId']
        }
        if data['description']:
            update_data['description'] = data['description']

        results.append(update_project(logger,
                                      message,
                                      update_data,
                                      orchard_client))
    else:
        # Create new project.
        create_data = {
            'projectCode': sony_local_id,
            'name': data['name'],
            'artistId': artist['artistInfoId'],
            'accountId': int(data['labelAccount']['companyCode']),
            'description': data['description'],
        }

        if 'subAccount' in data and data['subAccount'] is not None:
            create_data['subaccountId'] = int(
                data['subAccount']['companyCode'])

        results.append(create_project(logger,
                                      message,
                                      create_data,
                                      orchard_client))

    return results