"""Custom validators module unit test."""

import pytest
from src.constants import audio_standards
from src.constants import field_const
from src import custom_validators
from trafaret import DataError


@pytest.fixture
def correct_audio_metadata():
    """Correct audio metadata."""
    return {
        'container': 'wave',
        'codec': 'pcm',
        'bit_rate': 1411200,
        'bits_per_sample': 16,
        'channels': 2,
        'sample_rate': 44100,
        'file_size': 3413948,  # bytes
        'playtime_seconds': 2963  # ms
    }


@pytest.fixture
def correct_aac_metadata():
    """Correct audio metadata data."""
    return {
        'playtime_seconds': 2963,  # ms
        'channels': 2,
        'codec': 'ALAC',
        'bit_rate': 1411200,
        'sample_rate': 44100,
        'resolution': 16,
        'bits_per_sample': 16,
        'container': 'mpeg-4',
        'mime_type': 'audio/mp4',
        'file_size': 62501364,  # bytes
        'lossless': False,
        'channel_mode': 'stereo'
    }


@pytest.mark.parametrize('input_sample_rate, expected_sample_rate', [(44100, 44100), (48000, 48000)])
def test_sample_rate_validation_success(input_sample_rate, expected_sample_rate, correct_audio_metadata):
    """Test sample_rate_validation function success call."""
    audio_metadata = dict.copy(correct_audio_metadata)
    audio_metadata['sample_rate'] = input_sample_rate
    result = custom_validators.sample_rate_validation(audio_metadata)
    assert 'sample_rate' in result
    assert expected_sample_rate == result['sample_rate']


def test_sample_rate_validation_failure(correct_audio_metadata):
    """Test sample_rate_validation function failure call."""
    bits_per_sample = correct_audio_metadata['bits_per_sample']

    invalid_metadata = correct_audio_metadata
    invalid_metadata['sample_rate'] = 100

    expected_sample_rate_values = (
        field_const.ALLOWED_SAMPLE_RATES[bits_per_sample])
    expected_error_message = custom_validators.INVALID_INPUT_VALUE_ERROR_MESSAGE.format(
        name='sample_rate',
        expected=expected_sample_rate_values,
        value=invalid_metadata['sample_rate']
    )
    result = custom_validators.sample_rate_validation(invalid_metadata)

    assert 'sample_rate' in result
    assert type(result['sample_rate']) == DataError

    result_error_message = result['sample_rate'].as_dict()
    assert expected_error_message == result_error_message


@pytest.mark.parametrize('input_channels, input_bit_rate, expected_bit_rate', [(2, 1411200, 1411200)])
def test_wav_bit_rate_validation_success(input_channels, input_bit_rate, expected_bit_rate, correct_audio_metadata):
    """Test wav_bit_rate_validation function success call."""
    audio_metadata = dict.copy(correct_audio_metadata)
    audio_metadata['channels'] = input_channels
    audio_metadata['bit_rate'] = input_bit_rate
    result = custom_validators.wav_bit_rate_validation(audio_metadata)
    assert 'bit_rate' in result
    assert expected_bit_rate == result['bit_rate']


def test_wav_bit_rate_validation_failure(correct_audio_metadata):
    """Test wav_bit_rate_validation function failure call."""
    expected_bit_rate = correct_audio_metadata['bit_rate']
    invalid_metadata = dict.copy(correct_audio_metadata)
    invalid_metadata['bit_rate'] = 100
    expected_error_message = custom_validators.INVALID_INPUT_VALUE_ERROR_MESSAGE.format(
        name='bit_rate',
        expected=expected_bit_rate,
        value=invalid_metadata['bit_rate']
    )
    result = custom_validators.wav_bit_rate_validation(invalid_metadata)

    assert 'bit_rate' in result
    assert type(result['bit_rate']) == DataError

    result_error_message = result['bit_rate'].as_dict()
    assert expected_error_message == result_error_message


def test_wav_file_size_validation_success(correct_audio_metadata):
    """Test wav_file_size_validation function success call."""
    result = custom_validators.wav_file_size_validation(correct_audio_metadata)
    assert 'file_size' in result


def test_wav_file_size_validation_failure(correct_audio_metadata):
    """Test wav_file_size_validation function success call."""
    invalid_audio_meta = dict.copy(correct_audio_metadata)
    invalid_audio_meta['file_size'] = 230000
    file_size_minimum = (
        (correct_audio_metadata['playtime_seconds'] / 1000) * audio_standards.FILE_SIZE_PER_SECOND
    )

    expected_file_size_msg = 'greater than {}'.format(file_size_minimum)
    expected_error_message = custom_validators.INVALID_INPUT_VALUE_ERROR_MESSAGE.format(
        name='file_size',
        expected=expected_file_size_msg,
        value=invalid_audio_meta['file_size']
    )
    result = custom_validators.wav_file_size_validation(invalid_audio_meta)
    result_error_message = result['file_size'].as_dict()

    assert expected_error_message == result_error_message


def test_bits_per_sample_wave_validation_success(correct_audio_metadata):
    """Test bit_per_sample_validation function success call for PCM metadata."""
    result = custom_validators.bits_per_sample_validation(correct_audio_metadata)
    assert 'bits_per_sample' in result


def test_bits_per_sample_aac_validation_success(correct_aac_metadata):
    """Test bit_per_sample_validation function success call for AAC metadata."""
    result = custom_validators.bits_per_sample_validation(correct_aac_metadata)
    assert result == {'bits_per_sample': 16}


def test_bits_per_sample_wav_validation_error(correct_audio_metadata):
    """Test bit_per_sample_validation function failuyre call for PCM metadata."""
    invalid_audio_meta = dict.copy(correct_audio_metadata)
    invalid_audio_meta['bits_per_sample'] = 18

    expected_bits_per_sample_msg = 'not equal to 16 or 24 bits per sample'
    expected_error_message = custom_validators.INVALID_INPUT_VALUE_ERROR_MESSAGE.format(
        name='bits_per_sample',
        expected=expected_bits_per_sample_msg,
        value=invalid_audio_meta['bits_per_sample']
    )

    result = custom_validators.bits_per_sample_validation(invalid_audio_meta)
    result_error_message = result['bits_per_sample'].as_dict()
    assert expected_error_message == result_error_message