"""Tests for track localization validators."""

import pytest

from backend.constants import error
from backend.constants import services as services_const
from backend.constants import track_field as tf
from backend.constants import validation as validation_const
from backend.validation import \
    track_localization_validators as track_loc_validators
from tests.testutils import constants as test_consts
from tests.testutils import mocks


def test_validate_localizations_success(mocker):
    """Should return empty list."""
    track = {'tuid': 1, 'meta_language_code': 'US'}
    mocks.ows_product_get_localization_languages(mocker)
    result = track_loc_validators.validate_track_localization_set(
        track, [], product_meta_language='ENG')
    assert result == {}


def test_validate_localizations_error(mocker):
    """Should return list with error."""
    track = {
        'tuid': services_const.CHINESE_SIMPLIFIED_LANG_ID,
        'meta_language_code': 'CHI'
    }

    meta_language_error = {
        'message': error.VALIDATION_ERROR_CHINESE_LOCALIZATION_REQUIRED.format(
            track_language='Chinese Traditional',
            product_meta_language='Chinese Simplified'),
        'validator': 'required',
        'validator_value': True,
        'error_code': error.MISSING_CHINESE_LOCALIZATION
    }
    mocks.ows_product_get_localization_languages(mocker)
    result = track_loc_validators.validate_track_localization_set(
        track, [], product_meta_language='CHI')

    assert result == {'localizations': [meta_language_error]}


def test_validate_localizations(
        track_factory, track_localization_factory, mocker):
    """Localization language should not be the same as track language."""
    track = track_factory.create().to_dict()
    track_localizations = track_localization_factory(track, [1])

    mocks.ows_product_get_localization_languages(mocker)
    error_obj = track_loc_validators.validate_track_localization(
        track, track_localizations[0], product_meta_language='ENG')

    assert not error_obj


@pytest.mark.parametrize('meta_language_id, language_id, valid', [
    (10, 1, True), (2, 2, False), (None, 1, True), (1, None, False)
])
def test_validate_track_localization_language(
        meta_language_id, language_id, valid):
    """Localization language should not be the same as track language."""
    error_obj = track_loc_validators._validate_localization_language(
        meta_language_id, language_id)
    assert not bool(error_obj) == valid


@pytest.mark.parametrize('track_name, localized_track_name, valid', [
    ('XYZ', 'Кино', True), ('XYZ', '', True),
    ('XyZ', test_consts.TEST_TRACK_NAME_TOO_LONG, False),
    ('', '', True), ('', 'ABC', False),
    ('XYZ', None, True), (None, None, True)
])
def test_validate_localized_track_name(
        track_name, localized_track_name, valid):
    """Test localized track name validation."""
    error_obj = track_loc_validators._validate_localized_field_string(
        field_key=tf.TRACK_NAME,
        value=track_name, localized_value=localized_track_name,
        max_length=validation_const.TRACK_NAME_MAX_LENGTH)

    assert not bool(error_obj) == valid


def test_validate_artists_localized(track_factory):
    """Should return empty dict because all artists are localized."""
    track = track_factory.create(performer__count=2).to_dict()
    localized_artists = [
        {'type': 'performer', 'name': 'localized One', 'track_artist_id': 1},
        {'type': 'performer', 'name': 'localized Two', 'track_artist_id': 2}
    ]

    error_obj = track_loc_validators._validate_artists_localized(
        track[tf.ARTISTS], localized_artists)

    assert error_obj == {}


def test_validate_artists_localized_blank(track_factory):
    """Verify artist localizations can be left blank."""
    track = track_factory.create(performer__count=2).to_dict()
    localized_artists = []

    error_obj = track_loc_validators._validate_artists_localized(
        track[tf.ARTISTS], localized_artists)

    assert error_obj == {}


def test_validate_artists_localized_mixed(
        track_factory, track_localization_factory):
    """Verify artist localizations can only have some roles filled in."""
    track = track_factory.create(
        performer__count=2, remixer__count=1).to_dict()
    localized_artists = track_localization_factory(track, [1])[0][tf.ARTISTS]
    localized_artists = [
        a for a in localized_artists if a[tf.TYPE] == 'performer']

    error_obj = track_loc_validators._validate_artists_localized(
        track[tf.ARTISTS], localized_artists)

    assert error_obj == {}


@pytest.mark.parametrize('performer_count', [0, 2])
def test_validate_artists_localized_error_case(track_factory, performer_count):
    """Return error because localized artists don't match track artists."""
    track = track_factory.create(performer__count=performer_count).to_dict()
    localized_artists = [
        {'type': 'performer', 'name': 'localized One', 'track_artist_id': 1},
    ]
    expected_error = {
        'artists': {
            'validator': 'artists_mismatch',
            'validator_value': True,
            'message': error.LOCALIZATION_ERROR_LOCALIZED_VALUES_MISMATCH,
            'error_code': error.LOCALIZED_ARTISTS_MISMATCH
        }}

    error_obj = track_loc_validators._validate_artists_localized(
        track[tf.ARTISTS], localized_artists)

    assert error_obj == expected_error


def test_validate_all_artists_localized(track_factory):
    """Should return empty dict because all artists are localized."""
    track = track_factory.create(performer__count=2).to_dict()
    localized_artists = [
        {'type': 'performer', 'name': 'localized One', 'track_artist_id': 1},
        {'type': 'performer', 'name': 'localized Two', 'track_artist_id': 2}
    ]

    error_obj = track_loc_validators._validate_all_artists_localized(
        track[tf.ARTISTS], localized_artists)

    assert error_obj == {}


def test_validate_all_artists_localized_error_case(track_factory):
    """Should return error because not all artists are localized."""
    track = track_factory.create(performer__count=2).to_dict()
    localized_artists = [
        {'type': 'performer', 'name': 'localized One', 'track_artist_id': 1},
    ]
    expected_error = {
        'artists': {
            'validator': 'artists_mismatch',
            'validator_value': True,
            'message': error.LOCALIZATION_ERROR_LOCALIZED_VALUES_MISMATCH,
            'error_code': error.LOCALIZED_ARTISTS_MISMATCH
        }}

    error_obj = track_loc_validators._validate_all_artists_localized(
        track[tf.ARTISTS], localized_artists)

    assert error_obj == expected_error


def test_validate_chinese_meta_language():
    """Should validate that track has localization in complementary lang.

    When meta language of track is Chinese(simplified or traditional),
    complementary language must be localized.
    """
    localizations = [
        {
            'language_id': services_const.CHINESE_TRADITIONAL_LANG_ID,
            'artists': {'69153654': 'NEW Track Artist-Afr'},
            'track_name': '22 track2-Afr',
            'version': '22 Version-afr',
            'tuid': 21363833
        }
    ]

    validation_result = track_loc_validators._validate_chinese_meta_language(
        localizations, 6)

    assert validation_result == {}


@pytest.mark.parametrize(
    'language_id, language_code, required_language, product_meta_language',
    [
        (6, 'CHI', 'Chinese Traditional', 'Chinese Simplified'),
        (7, 'cmn-Hant', 'Chinese Simplified', 'Chinese Traditional')])
def test_validate_chinese_meta_language_error_case(
        language_id, language_code, required_language, product_meta_language):
    """Should return error when complementary Chinese language not provided."""
    localizations = [
        {
            'language_id': 1,  # non-Chinese language_id
            'artists': {'69153654': 'NEW Track Artist-Afr'},
            'track_name': '22 track2-Afr',
            'version': '22 Version-afr',
            'tuid': 21363833
        }
    ]
    expected_error = {
        'message': error.VALIDATION_ERROR_CHINESE_LOCALIZATION_REQUIRED.format(
            track_language=required_language,
            product_meta_language=product_meta_language),
        'validator': 'required',
        'validator_value': True,
        'error_code': error.MISSING_CHINESE_LOCALIZATION
    }

    validation_result = track_loc_validators._validate_chinese_meta_language(
        localizations, language_id)

    assert validation_result == expected_error


def test_non_required_language_returns_no_error():
    """Should return empty dict for not required language localization."""
    localizations = [
        {
            'language_id': 2,
            'artists': {'69153654': 'NEW Track Artist-Afr'},
            'track_name': '22 track2-Afr',
            'version': '22 Version-afr',
            'tuid': 21363833
        }
    ]

    validation_result = track_loc_validators._validate_chinese_meta_language(
        localizations, 1)
    assert validation_result == {}


def test_chinese_language_validation_with_empty_localizations():
    """Should return error if ows-product returned empty list."""
    expected_error = {
        'message': error.VALIDATION_ERROR_CHINESE_LOCALIZATION_REQUIRED.format(
            track_language='Chinese Traditional',
            product_meta_language='Chinese Simplified'),
        'validator': 'required',
        'validator_value': True,
        'error_code': error.MISSING_CHINESE_LOCALIZATION
    }
    validation_result = track_loc_validators._validate_chinese_meta_language(
        [], 6)

    assert validation_result == expected_error


def test_validate_chinese_localizations_success():
    """Should return empty dict because localizations are valid."""
    localizations = [
        {
            'language_id': services_const.CHINESE_SIMPLIFIED_LANG_ID,
            'artists': {'69153654': 'NEW Track Artist-Afr'},
            'track_name': '22 track2-Afr',
            'version': '22 Version-afr',
            'tuid': 1
        },
        {
            'language_id': services_const.CHINESE_TRADITIONAL_LANG_ID,
            'artists': {'69153654': 'NEW Track Artist-Afr'},
            'track_name': '22 track2-Afr',
            'version': '22 Version-afr',
            'tuid': 1
        }
    ]

    result = track_loc_validators._validate_chinese_localizations(
        localizations, 1)

    assert result == {}


def test_validate_chinese_localizations_with_chinese_meta_language():
    """Should be no error, because meta_language is Chinese."""
    result = track_loc_validators._validate_chinese_localizations([], 6)

    assert result == {}


def test_validate_chinese_localizations_one_missing():
    """Should return error because on of localizations is missing."""
    localizations = [
        {
            'language_id': services_const.CHINESE_SIMPLIFIED_LANG_ID,
            'artists': {'69153654': 'NEW Track Artist-Afr'},
            'track_name': '22 track2-Afr',
            'version': '22 Version-afr',
            'tuid': 1
        }
    ]
    expected_error = {
        'message': error.VALIDATION_ERROR_BOTH_CHINESE_LANGS_REQUIRED,
        'validator': 'required',
        'validator_value': True,
        'error_code': error.MISSING_BOTH_CHINESE_LANGUAGES
    }

    result = track_loc_validators._validate_chinese_localizations(
        localizations, 1)

    assert result == expected_error


def test_validate_chinese_localizations_no_localizations():
    """Should return empty dict because neither of Chinese langs localized."""
    result = track_loc_validators._validate_chinese_localizations([], 1)

    assert result == {}


def test_validate_number_of_localizations_success():
    """Should validate that there are at most 5 localizations of track."""
    localizations = [{'tuid': 1}]

    validation_result = track_loc_validators._validate_number_of_localizations(
        localizations)

    assert validation_result == {}


def test_validate_number_of_localizations_error():
    """Should validate that there are at most 5 localizations of track."""
    localizations = [{'tuid': 1}] * 6
    expected_error = {
        'message': error.LOCALIZATION_ERROR_TOO_MANY_LOCALIZATIONS,
        'validator': 'required',
        'validator_value': True,
        'error_code': error.TOO_MANY_LOCALIZATIONS
    }

    validation_result = track_loc_validators._validate_number_of_localizations(
        localizations)

    assert validation_result == expected_error


def test_validate_localizations_by_product_meta_language(
        mocker, mock_app, track_factory, track_localization_factory):
    """Localization language should not be the same as track language."""
    expected_error_message = \
        error.VALIDATION_ERROR_SIMILAR_LOCALIZATION.format('product')

    track = track_factory.create().to_dict()
    track_localizations = track_localization_factory(track, [12])

    mocks.ows_product_get_localization_languages(mocker)
    error_obj = track_loc_validators.validate_track_localization(
        track, track_localizations[0], product_meta_language='ENG')

    assert error_obj['language']['message'] == expected_error_message
    assert error_obj