"""Unit tests for tracks.py."""
from switchboard_consumer.constants.error import (
    ERROR_CODE_TRACK_PROCESSING,
    ERROR_MESSAGE_TRACK_INSERT_FAILED,
    ERROR_MESSAGE_TRACK_INSERT_FAILED_PARSING,
    ERROR_MESSAGE_TRACK_INSERT_RAW_ERROR
)
from switchboard_consumer.constants.system import SONY
from switchboard_consumer.logic.tracks import \
    create_tracks


def test_create_tracks_failure(create_product_message,
                               mock_logger, orchard_client):
    """Test for failure on create tracks."""
    create_tracks_payload = [
        {
            'isrc': 'GBBKS1000335'
        },
        {
            'isrc': 'GBBKS1000336'
        },
        {
            'isrc': 'GBBKS1000337'
        },
    ]

    swb_tracks_local_id_mapping = {
        'GBBKS1000335': {
            'system': SONY,
            'localId': '20001',
        },
        'GBBKS1000336': {
            'system': SONY,
            'localId': '20002'
        },
        'GBBKS1000337': {
            'system': SONY,
            'localId': '20003'
        }
    }

    mock_product_id = 12345
    orchard_client.create_tracks.return_value = {
        'errors': [
            {
                'path': [
                    'saveTracks'
                ],
                'extensions': {
                    'code': 'create_tracks_error_code',
                    'response': {
                        'body': {
                            'message': {
                                'tracks': {
                                    '2': {
                                        'isrc': [
                                            'Not valid'
                                        ],
                                        'writers': {
                                            '0': {
                                                'type': [
                                                    'Not a valid choice.'
                                                ]
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                },
                'message': '400: BAD REQUEST',
            }
        ],
        'data': {
            'saveTracks': None
        }
    }

    success, results = create_tracks(
        mock_logger, create_product_message, orchard_client, mock_product_id,
        create_tracks_payload, swb_tracks_local_id_mapping, {})

    assert success is False
    # We should have 3 track processing results
    assert len(results) == 3

    # The first and second tracks will have failed with generic message
    assert results[0]['errors'] == [
        {
            'code': ERROR_CODE_TRACK_PROCESSING,
            'message': ERROR_MESSAGE_TRACK_INSERT_FAILED
        }
    ]

    assert results[0]['ids'] == [
        {
            'businessKey': 'GBBKS1000335',
            'businessKeyType': 'ISRC',
            'system': SONY,
            'localId': '20001',
        }
    ]

    assert results[1]['errors'] == [
        {
            'code': ERROR_CODE_TRACK_PROCESSING,
            'message': ERROR_MESSAGE_TRACK_INSERT_FAILED
        }
    ]
    assert results[1]['ids'] == [
        {
            'businessKey': 'GBBKS1000336',
            'businessKeyType': 'ISRC',
            'system': SONY,
            'localId': '20002',
        }
    ]

    # Our third track has parsable errors from graphql
    # One error regarding writers and one regarding ISRC
    assert len(results[2]['errors']) == 2
    assert results[2]['errors'] == [
        {
            'code': 'processing',
            'message': 'Track failed to insert: isrc_0 - Not valid'
        },
        {
            'code': 'processing',
            'message':
            'Track failed to insert: writers_0_type_0 - Not a valid choice.'
        }
    ]
    assert results[2]['ids'] == [
        {
            'businessKey': 'GBBKS1000337',
            'businessKeyType': 'ISRC',
            'system': SONY,
            'localId': '20003',
        }
    ]


def test_create_track_partial_failure_handling(
        create_product_message, mock_logger, orchard_client):
    """Test that processing results are correct for partial track failures."""
    create_tracks_payload = [
        {
            'isrc': 'GBBKS1000335'
        },
        {
            'isrc': 'GBBKS1000336'
        },
        {
            'isrc': 'GBBKS1000337'
        },
    ]

    swb_tracks_local_id_mapping = {
        'GBBKS1000335': {
            'system': SONY,
            'localId': '20001',
        },
        'GBBKS1000336': {
            'system': SONY,
            'localId': '20002'
        },
        'GBBKS1000337': {
            'system': SONY,
            'localId': '20003'
        }
    }

    mock_product_id = 12345

    track_2_error_message = 'Artist types `artist` are missing'
    track_3_error_message = {
        'performers': {
            '0': {
                'type': [
                    'Not a valid choice.'
                ]
            }
        }
    }
    # The 2nd and 3rd track has a failure
    orchard_client.create_tracks.return_value = {
        'errors': [
            {
                'path': [
                    'saveTracks',
                    1
                ],
                'extensions': {
                    'code': 'INTERNAL_SERVER_ERROR',
                    'response': {
                        'url':
                        'https://qa-ows-track.theorchard.io/track/123/samples',
                        'status': 400,
                        'statusText': 'BAD REQUEST',
                        'body': {
                            'code': 'validation_error',
                            'message': track_2_error_message
                        }
                    },
                },
                'message': '400: BAD REQUEST',
            },
            {
                'path': [
                    'saveTracks',
                    2
                ],
                'extensions': {
                    'code': 'INTERNAL_SERVER_ERROR',
                    'response': {
                        'url': 'https://qa-ows-track.theorchard.io',
                        'status': 400,
                        'statusText': 'BAD REQUEST',
                        'body': {
                            'code': 'validation_error',
                            'message': track_3_error_message}
                    },
                },
                'message': '400: BAD REQUEST',
            },
        ],
        'data': {
            'saveTracks': [
                {
                    'tuid': '30906649',
                    'isrc': 'GBBKS1000335',
                },
                None,
                None
            ]
        }
    }

    track_1_expected_mapping = [
        {
            'localId': '30906649',
            'system': 'ORCHARD',
            'businessKeyType': 'ISRC',
            'businessKey': 'GBBKS1000335'
        },
        {
            'localId': '20001',
            'system': 'SONY',
            'businessKeyType': 'ISRC',
            'businessKey': 'GBBKS1000335'
        }
    ]

    success, results = create_tracks(
        mock_logger, create_product_message, orchard_client, mock_product_id,
        create_tracks_payload, swb_tracks_local_id_mapping, {})

    assert success is False
    # We should have 3 track processing results
    assert len(results) == 3

    # Track 1 should have a successful mapping
    assert not results[0]['errors']
    assert results[0]['ids'] == track_1_expected_mapping

    # Track 2 should have a stringified error message
    assert results[1]['errors'] == [
        {
            'code': ERROR_CODE_TRACK_PROCESSING,
            'message': ERROR_MESSAGE_TRACK_INSERT_RAW_ERROR.format(
                track_2_error_message
            )
        }
    ]

    # Track 3 should have a stringified error message
    assert results[2]['errors'] == [
        {
            'code': ERROR_CODE_TRACK_PROCESSING,
            'message': ERROR_MESSAGE_TRACK_INSERT_RAW_ERROR.format(
                track_3_error_message
            )
        }
    ]


def test_create_product_failure_create_tracks_invalid_error_data(
        create_product_message, mock_logger, orchard_client):
    """Test for failure on create tracks with invalid error data."""
    create_tracks_payload = [
        {
            'isrc': 'GBBKS1000335'
        },
        {
            'isrc': 'GBBKS1000336'
        },
        {
            'isrc': 'GBBKS1000337'
        },
    ]

    swb_tracks_local_id_mapping = {
        'GBBKS1000335': {
            'system': SONY,
            'localId': '20001',
        },
        'GBBKS1000336': {
            'system': SONY,
            'localId': '20002'
        },
        'GBBKS1000337': {
            'system': SONY,
            'localId': '20003'
        }
    }

    mock_product_id = 12345

    # Our create track error does not have any tracks key
    orchard_client.create_tracks.return_value = {
        'errors': [
            {
                'path': [
                    'saveTracks'
                ],
                'extensions': {
                    'code': 'create_tracks_error_code',
                    'response': {
                        'body': {
                            'message': {
                                'something_that_we_do_not_handle': {
                                    'nice': [
                                        'errors'
                                    ]
                                }
                            }
                        }
                    }
                },
                'message': '400: BAD REQUEST',
            }
        ]
    }

    success, results = create_tracks(
        mock_logger, create_product_message, orchard_client, mock_product_id,
        create_tracks_payload, swb_tracks_local_id_mapping, {})
    assert success is False
    # We should have 3 track processing results
    assert len(results) == 3

    # Tracks should have a generic error message as we cannot parse errors

    for result in results:
        assert result['errors'] == [
            {
                'code': ERROR_CODE_TRACK_PROCESSING,
                'message': ERROR_MESSAGE_TRACK_INSERT_RAW_ERROR.format(
                    ERROR_MESSAGE_TRACK_INSERT_FAILED_PARSING)
            }
        ]


def test_create_tracks_success(
        create_product_message, mock_logger, orchard_client):
    """Test for success on create tracks."""
    create_tracks_payload = [
        {
            'isrc': 'GBBKS1000330',
            'publishers': [
                {
                    'name': 'Publisher 1 1'
                },
                {
                    'name': 'Publisher 1 2'
                }
            ]
        },
        {
            'isrc': 'GBBKS1000331',
            'publishers': [
                {
                    'name': 'Publisher 2 1'
                }
            ]
        },
        {
            'isrc': 'GBBKS1000332',
            'publishers': [
                {
                    'name': 'Publisher 3 1'
                }
            ]
        },
    ]

    swb_tracks_local_id_mapping = {
        'GBBKS1000330': {
            'system': SONY,
            'localId': '20001',
        },
        'GBBKS1000331': {
            'system': SONY,
            'localId': '20002'
        },
        'GBBKS1000332': {
            'system': SONY,
            'localId': '20003'
        }
    }

    mock_product_id = 12345
    orchard_client.create_tracks.return_value = \
        [
            {
                'tuid': '30906640',
                'isrc': 'GBBKS1000330',
                'publishing': {
                    'publisherNames': ['Publisher 1 1', 'Publisher 1 2']
                }
            },
            {
                'tuid': '30906641',
                'isrc': 'GBBKS1000331',
                'publishing': {
                    'publisherNames': ['Publisher 2 1']
                }
            },
            {
                'tuid': '30906642',
                'isrc': 'GBBKS1000332',
                'publishing': {
                    'publisherNames': ['Publisher 3 1']
                }
            },

        ]

    unmapped_publishers = {
        'GBBKS1000330': [
            ['Publisher 1 1', {'system': 'SONY', 'localId': 'SONY:100011'}]
        ],
        'GBBKS1000332': [
            ['Publisher 3 1', {'system': 'SONY', 'localId': 'SONY:100031'}]
        ]
    }
    success, results = create_tracks(
        mock_logger, create_product_message, orchard_client, mock_product_id,
        create_tracks_payload, swb_tracks_local_id_mapping,
        unmapped_publishers)

    assert success is True

    assert len(results) == 5
    assert all([result['entityType'] == 'TRACK' for result in results[:3]])

    publisher_1_1_results = results[3]
    assert publisher_1_1_results['entityType'] == 'PUBLISHER'
    assert publisher_1_1_results['ids'] == [
        {
            'localId': 'SONY:100011',
            'system': 'SONY'
        },
        {
            'localId': 'UNID:hXHB6KL5gx/CsLBfdNKpUkP3KAY=',
            'system': 'ORCHARD'
        }
    ]

    publisher_3_1_results = results[4]
    assert publisher_3_1_results['entityType'] == 'PUBLISHER'
    assert publisher_3_1_results['ids'] == [
        {
            'localId': 'SONY:100031',
            'system': 'SONY'
        },
        {
            'localId': 'UNID:qcV4r4NR7K0w26inofVfhzhg4K8=',
            'system': 'ORCHARD'
        }
    ]