"""Test logic track_sample."""
from oto import response
import pytest

from backend.constants import error
from backend.constants import track_sample as const
from backend.logic import track_sample
from backend.models import track_sample as sample_model


def test_create_track_sample_valid(
        mocker, track_sample_tuid, valid_track_sample_request):
    """Test create_track_sample with all valid values."""
    expected_response = response.Response(message={'foo': 'bar'}, status=200)
    mocker.patch.object(
        sample_model, 'create_new_sample', return_value=expected_response)

    actual = track_sample.create_track_sample(
        track_sample_tuid, valid_track_sample_request)
    assert actual == expected_response


def test_create_track_sample_just_required(
        mocker, track_sample_tuid, valid_track_sample_request):
    """Test create_track_sample with just required fields."""
    expected_response = response.Response(message={'foo': 'bar'}, status=200)
    mocker.patch.object(
        sample_model, 'create_new_sample', return_value=expected_response)
    # remove optional fields
    del valid_track_sample_request['isrc']
    del valid_track_sample_request['p_line']
    del valid_track_sample_request['track_length']
    del valid_track_sample_request['notes']

    actual = track_sample.create_track_sample(
        track_sample_tuid, valid_track_sample_request)
    assert actual == expected_response


@pytest.mark.parametrize('missing', const.SAMPLE_REQUIRED_FIELDS)
def test_create_track_sample_missing_required(
        mocker, track_sample_tuid, valid_track_sample_request, missing):
    """Test create_track_sample with missing SAMPLE_REQUIRED_FIELDS."""
    valid_response = response.Response(message={'foo': 'bar'}, status=200)
    mocker.patch.object(
        sample_model, 'create_new_sample', return_value=valid_response)
    del valid_track_sample_request[missing]

    actual = track_sample.create_track_sample(
        track_sample_tuid, valid_track_sample_request)
    assert actual.status == 400
    assert actual.errors['code'] == 'validation_error'
    error_msg = error.VALIDATION_ERROR_MISSING_FIELD_MSG.format(missing)
    assert actual.errors['message'] == error_msg


@pytest.mark.parametrize(('missing', 'code', 'result'), [
    (const.ARTIST_TYPE, 400, error.MISSING_ARTIST_TYPE.format(
        const.ARTIST_TYPE)),
    (const.SONGWRITER_TYPE, 200, {'foo': 'bar'}),
    (const.PRODUCER_TYPE, 200, {'foo': 'bar'}),
])
def test_create_track_sample_missing_artist(
        mocker, track_sample_tuid, valid_track_sample_request, missing,
        code, result):
    """Test create_track_sample with missing any ARTIST_TYPES."""
    valid_response = response.Response(message={'foo': 'bar'}, status=200)
    mocker.patch.object(
        sample_model, 'create_new_sample', return_value=valid_response)

    new_artists = [artist for artist in valid_track_sample_request['artists']
                   if artist['artist_type'] != missing]
    valid_track_sample_request['artists'] = new_artists
    actual = track_sample.create_track_sample(
        track_sample_tuid, valid_track_sample_request)
    assert actual.status == code
    if code == 200:
        assert actual.message == result
    else:
        assert actual.errors['message'] == result


def test_get_track_sample_found(mocker):
    """Test get_sample_data with sample_id that exists."""
    expected_response = response.Response(message={'foo': 'bar'}, status=200)
    mocker.patch.object(
        sample_model, 'get_sample_data', return_value=expected_response)

    actual = track_sample.get_track_sample(1)
    assert actual == expected_response


def test_get_track_sample_not_found(mocker):
    """Test get_sample_data with sample_id that don't exists."""
    expected_response = response.create_not_found_response(message='foo')
    mocker.patch.object(
        sample_model, 'get_sample_data', return_value=expected_response)

    actual = track_sample.get_track_sample(10000)
    assert actual == expected_response


def test_delete_sample_data_found(mocker):
    """Test delete_sample_data with sample_id that exists."""
    expected_response = response.Response(message={'foo': 'bar'}, status=200)
    mocker.patch.object(
        sample_model, 'delete_sample_data', return_value=expected_response)

    actual = track_sample.delete_sample_data(1)
    assert actual == expected_response


def test_delete_sample_data_not_found(mocker):
    """Test delete_sample_data with sample_id that don't exists."""
    expected_response = response.create_not_found_response(message='foo')
    mocker.patch.object(
        sample_model, 'delete_sample_data', return_value=expected_response)

    actual = track_sample.delete_sample_data(10000)
    assert actual == expected_response


def test_update_sample_data_missing_required(mocker, track_sample_id):
    """Test update_sample_data with no change."""
    valid_response = response.Response(message={'foo': 'bar'}, status=200)
    mocker.patch.object(
        sample_model, 'update_sample_data', return_value=valid_response)

    actual = track_sample.update_sample_data(track_sample_id, {})
    assert actual
    assert actual.message == {'foo': 'bar'}


def test_update_sample_data_valid(
        mocker, track_sample_id, valid_track_sample_request):
    """Test update_sample_data with valid values."""
    valid_response = response.Response(message={'foo': 'bar'}, status=200)
    mocker.patch.object(
        sample_model, 'update_sample_data', return_value=valid_response)

    actual = track_sample.update_sample_data(
        track_sample_id, valid_track_sample_request)
    assert actual
    assert actual.message == {'foo': 'bar'}


def test_update_sample_data_invalid(mocker, track_sample_id):
    """Test update_sample_data with invalid sample_type values."""
    valid_response = response.Response(message={'foo': 'bar'}, status=200)
    mocker.patch.object(
        sample_model, 'update_sample_data', return_value=valid_response)

    actual = track_sample.update_sample_data(
        track_sample_id, {'sample_type': 'test'})
    assert actual.status == 400
    error_msg = error.VALIDATION_ERROR_INVALID_FIELD_MSG.format('sample_type')
    assert actual.errors['message'] == error_msg


def test_update_sample_data_invalid_artist(mocker, track_sample_id):
    """Test update_sample_data with invalid artist type values."""
    valid_response = response.Response(message={'foo': 'bar'}, status=200)
    mocker.patch.object(
        sample_model, 'update_sample_data', return_value=valid_response)

    data = {'sample_type': 're_recording', 'artists': [
        {'artist_name': 'a', 'artist_type': 'tests'}]}
    actual = track_sample.update_sample_data(track_sample_id, data)
    assert actual.status == 400
    error_msg = error.INVALID_ARTIST_TYPE_ERROR_MSG.format('tests')
    assert actual.errors['message'] == error_msg


def test_bulk_delete_samples_by_tuids(mocker, track_sample_id):
    """Test bulk_delete_samples_by_tuids with valid data."""
    valid_response = response.Response(message={'foo': 'bar'}, status=200)
    mocker.patch.object(
        sample_model, 'bulk_delete_by_tuids', return_value=valid_response)

    actual = track_sample.bulk_delete_samples_by_tuids([track_sample_id])
    assert actual
    assert actual.message == {'foo': 'bar'}


def test_bulk_delete_samples_invalid_data(mocker):
    """Test bulk_delete_samples_by_tuids with invalid data."""
    valid_response = response.Response(message={'foo': 'bar'}, status=200)
    mocker.patch.object(
        sample_model, 'bulk_delete_by_tuids', return_value=valid_response)

    actual = track_sample.bulk_delete_samples_by_tuids(12334)
    assert actual.status == 400
    assert actual.errors['code'] == error.INVALID_VALUE_ERROR_CODE


def test_copy_tracks(mocker):
    """Test copy_tracks when copy pass."""
    valid_response = response.Response(message={'foo': 'bar'})
    mapping = [(100, 10001), (200, 20001)]
    mocker.patch.object(
        sample_model, 'get_samples_by_tuids', return_value=valid_response)
    mocker.patch.object(
        sample_model, 'copy_multiple_samples', return_value=valid_response)

    actual = track_sample.copy_tracks(mapping)
    assert actual == valid_response


def test_copy_tracks_failure(mocker, mock_app):
    """Test copy_tracks when copy samples fails."""
    valid_response = response.Response(message={'foo': 'bar'})
    error_response = response.create_fatal_response('db error')
    mapping = [(100, 10001), (200, 20001)]
    mocker.patch.object(
        sample_model, 'get_samples_by_tuids', return_value=valid_response)
    mocker.patch.object(
        sample_model, 'copy_multiple_samples', return_value=error_response)
    with mock_app:
        mock_g = mocker.patch('backend.logic.track_sample.g')
        actual = track_sample.copy_tracks(mapping)
    assert actual == error_response
    assert mock_g.log.error.called