"""Test model track_sample."""
from copy import deepcopy

from oto import error

from backend.models import track_sample
from tests.testutils import db


@db.test_schema_no_seed
def test_create_new_sample_valid(
        track_sample_tuid, valid_track_sample, valid_track_sample_artist,
        valid_track_sample_response):
    """Test create_new_sample function with all valid values."""
    actual = track_sample.create_new_sample(
        track_sample_tuid, valid_track_sample, valid_track_sample_artist)

    assert actual.status == 200
    del actual.message['updated_date']
    assert actual.message == valid_track_sample_response


@db.test_schema_no_seed
def test_create_new_sample_invalid():
    """Test create_new_sample function when it will throw SQL exception."""
    tuid = 100
    actual = track_sample.create_new_sample(tuid, {}, [])

    assert actual.status == 500
    assert actual.errors['code'] == error.ERROR_CODE_INTERNAL_ERROR


@db.test_schema
def test_get_sample_data_found(track_sample_id, valid_track_sample_response):
    """Test get_sample_data when valid sample id."""
    actual = track_sample.get_sample_data(track_sample_id)
    assert actual.status == 200
    del actual.message['updated_date']
    assert actual.message == valid_track_sample_response


@db.test_schema
def test_get_sample_data_not_found():
    """Test get_sample_data when sample is not found."""
    actual = track_sample.get_sample_data(10000)
    assert actual.status == 404


@db.test_schema
def test_delete_sample_data_found(track_sample_id):
    """Test delete_sample_data when valid sample id."""
    actual = track_sample.delete_sample_data(track_sample_id)
    assert actual.status == 200


@db.test_schema
def test_delete_sample_data_not_found():
    """Test delete_sample_data when sample is not found."""
    actual = track_sample.delete_sample_data(10000)
    assert actual.status == 404


@db.test_schema
def test_get_track_samples_found(
        track_sample_tuid, valid_track_sample_response):
    """Test get_track_samples when samples are found."""
    actual = track_sample.get_track_samples(track_sample_tuid)
    assert actual
    del actual.message[0]['updated_date']
    assert actual.message == [valid_track_sample_response]


@db.test_schema
def test_get_track_samples_not_found():
    """Test get_track_samples when no samples exist for that track."""
    actual = track_sample.get_track_samples(123456)
    assert actual
    assert actual.message == []


@db.test_schema
def test_update_sample_valid(
        track_sample_id, valid_track_sample, valid_track_sample_response):
    """Test update_sample_data with valid values."""
    valid_track_sample['track_name'] = 'name changed'
    valid_track_sample['p_line'] = '1969 demo company'

    actual = track_sample.update_sample_data(
        track_sample_id, valid_track_sample, [])
    valid_track_sample_response['track_name'] = 'name changed'
    valid_track_sample_response['p_line'] = '1969 demo company'
    assert actual
    del actual.message['updated_date']
    assert actual.message == valid_track_sample_response


@db.test_schema
def test_update_sample_not_found(valid_track_sample):
    """Test update_sample_data with invalid sample id."""
    actual = track_sample.update_sample_data(1232323, valid_track_sample, [])
    assert actual.status == 404


@db.test_schema
def test_bulk_delete_by_tuids_found(track_sample_tuid):
    """Test bulk_delete_by_tuids when valid track ids."""
    actual = track_sample.bulk_delete_by_tuids([track_sample_tuid])
    assert actual.status == 200


@db.test_schema
def test_bulk_delete_by_tuids_not_found():
    """Test bulk_delete_by_tuids with invalid track ids it still is success."""
    actual = track_sample.bulk_delete_by_tuids([1232433243])
    assert actual.status == 200


@db.test_schema
def test_get_samples_by_tuids_found(
        track_sample_tuid, valid_track_sample_response):
    """Test get_samples_by_tuids when tuids are found."""
    actual = track_sample.get_samples_by_tuids([track_sample_tuid])
    assert actual
    del actual.message[0]['updated_date']
    assert actual.message == [valid_track_sample_response]


@db.test_schema
def test_get_samples_by_tuids_not_found():
    """Test get_samples_by_tuids when no samples are found."""
    actual = track_sample.get_samples_by_tuids([1, 2, 3])
    assert actual
    assert actual.message == []


@db.test_schema
def test_copy_multiple_samples(track_sample_tuid, valid_track_sample_response):
    """Test copy_multiple_samples and sample artists."""
    dest1 = 200
    dest2 = 300
    source1 = deepcopy(valid_track_sample_response)
    source2 = deepcopy(valid_track_sample_response)
    source1['unique_track_id'] = 10001
    source2['unique_track_id'] = 20001
    mapping = {
        source1['unique_track_id']: dest1,
        source2['unique_track_id']: dest2}

    copy_response = track_sample.copy_multiple_samples([source1], mapping)
    assert copy_response
    # get samples for dest tuids and compare with original data.
    get_response = track_sample.get_samples_by_tuids(mapping.values())
    assert get_response
    assert len(get_response.message) == 1
    for field, value in get_response.message[0].items():
        if field in ['sample_id', 'updated_date', 'unique_track_id']:
            assert value != valid_track_sample_response.get(field)
        elif field == 'artists':
            assert len(value) == len(valid_track_sample_response.get(field))
        else:
            assert value == valid_track_sample_response.get(field)