"""Tests for Track validation module."""
import pytest

from switchboard_consumer.constants.track_sample_type import \
    ORIGINAL_RECORDING, RE_RECORDING
from switchboard_consumer.constants.track_type import \
    SAMPLE, TRACK, UNKNOWN
from switchboard_consumer.constants.validation import \
    NO_TRACK_TYPE, VALIDATION_CODE
from switchboard_consumer.logic.validation.track.rules import \
    valid_pline, valid_track_sample, valid_track_type
from switchboard_consumer.logic.validation.track.validate import \
    validate_track
from switchboard_consumer.logic.validation.track.validators import \
    validate_pline, validate_track_sample, \
    validate_track_samples_names_unique, validate_track_type
from tests.logic.validation.track_test_data import \
    missing_track_type, track_with_invalid_pLine, \
    track_with_valid_sample_type


# Test rules.

@pytest.mark.parametrize('track_type,expected', [
    ('MEDLEY', False),
    (None, False),
    (SAMPLE, True),
    (TRACK, True)
])
def test_track_type(track_type, expected):
    """Test that a product with an invalid track type will be rejected."""
    valid = valid_track_type(track_type)
    assert valid == expected


@pytest.mark.parametrize('sample_type,expected', [
    ('WrongSampleType', False),
    (None, False),
    (RE_RECORDING, True),
    (ORIGINAL_RECORDING, True)
])
def test_track_sample_type(sample_type, expected):
    """Test track sample type."""
    valid = valid_track_sample(sample_type)
    assert valid == expected


@pytest.mark.parametrize('p_line,expected', [
    (None, False),
    ('2019, Whoever', False),
    ('2019,Whoever', False),
    ('2019 Whoever', True),
    ('2019 , Whoever', True),
    ('2019, 2020 Rem Records', True),
    ('2019, 2020, 2021 Rem Records', True),
    ('2019, 2020. 2021 Rem Records', False),
    ('', True),
    (' ', False),
])
def test_p_line(p_line, expected):
    """Test p line."""
    valid = valid_pline(p_line)
    assert valid == expected

# Test validation functions.


def test_validate_track_with_invalid_track_type():
    """Test validate track with an invalid track type."""
    track_type = 'UNKNOWN'
    isrc = 'GBAYE1234567'
    expected_error_message = {
        'code': VALIDATION_CODE,
        'message': NO_TRACK_TYPE.format(isrc, track_type)
    }
    error_message = validate_track_type(track_type, isrc)
    assert error_message == expected_error_message


def test_validate_track_with_valid_track_type():
    """Test validate track with a valid track type."""
    track_type = 'TRACK'
    isrc = 'GBAYE1234567'
    expected_error_message = None
    error_message = validate_track_type(track_type, isrc)
    assert error_message == expected_error_message


def test_validate_track_sample_with_valid_sample():
    """Test validate track sample with an invalid track sample type."""
    track_sample = {
        'displayTitle': 'Title 1',
        'sampleType': 'RE_RECORDING'
    }
    isrc = 'GBAYE1234567'
    expected_error_message = None
    error_message = validate_track_sample(track_sample, isrc)
    assert error_message == expected_error_message


def test_validate_track_sample_with_missing_sample():
    """Test validate track sample with a missing track sample type."""
    track_sample = {
        'displayTitle': 'Title 1',
    }
    isrc = 'GBAYE1234567'
    expected_error_message = {
        'code': VALIDATION_CODE,
        'message': 'Track with ISRC: {} '
                   'has sample with type: {}'.format(isrc, UNKNOWN)
    }
    error_message = validate_track_sample(track_sample, isrc)
    assert error_message == expected_error_message


def test_validate_track_sample_with_invalid_sample():
    """Test validate track sample with an invalid track sample type."""
    track_sample = {
        'displayTitle': 'Title 1',
        'sampleType': 'BAD_SAMPLE',
    }
    isrc = 'GBAYE1234567'
    expected_error_message = {
        'code': VALIDATION_CODE,
        'message': 'Track with ISRC: {} '
                   'has sample with type: {}'.format(isrc, 'BAD_SAMPLE')
    }
    error_message = validate_track_sample(track_sample, isrc)
    assert error_message == expected_error_message


def test_validate_p_line_with_valid_pline():
    """Test validate track with an valid p line."""
    p_line = ''
    expected_error_message = None
    error_message = validate_pline(p_line)
    assert error_message == expected_error_message


def test_validate_p_line_with_invalid_pline():
    """Test validate track with an valid p line."""
    p_line = 'Bad p line'
    expected_error_message = {
        'code': VALIDATION_CODE,
        'message': 'Invalid pLine: {}'.format(p_line)
    }
    error_message = validate_pline(p_line)
    assert error_message == expected_error_message


# Validate

def test_validate_track_with_invalid_track(create_product_message):
    """Test validate track with a valid track."""
    message = create_product_message
    processing_result = validate_track(missing_track_type, message)
    assert processing_result


def test_validate_track_with_valid_track(create_product_message):
    """Test validate track with an invalid track."""
    message = create_product_message
    track = track_with_valid_sample_type.get('track')
    processing_result = validate_track(track, message)
    assert processing_result is None


def test_validate_track_with_invalid_p_line(create_product_message):
    """Test validate track with an invalid track."""
    message = create_product_message
    processing_result = validate_track(track_with_invalid_pLine, message)
    assert processing_result


def test_validate_track_samples_names_unique_correct_data(
        track_samples_with_unique_names):
    """Check for success on unique names."""
    processing_result = validate_track_samples_names_unique(
        track_samples_with_unique_names)
    assert processing_result is None


def test_validate_track_samples_names_unique_not_correct_data(
        track_samples_with_duplicate_names):
    """Check for failure on duplicate names."""
    processing_result = validate_track_samples_names_unique(
        track_samples_with_duplicate_names)
    assert processing_result == {
        'code': VALIDATION_CODE,
        'message': 'Duplicate sample names: [\'Baby Blue 1\']'
    }