"""Test for release_phonetic_translations model."""
from unittest.mock import MagicMock

from alchemy_mock.comparison import ExpressionMatcher
import pytest

from product.models import release_phonetic_translations as rpt_model
from product.models.release_phonetic_translations\
    import PhoneticTranslations


@pytest.fixture
def session(mocker):
    """Fixture for session instance."""
    session = mocker.patch(
        'product.models.release_phonetic_translations.mysql.db_session')\
        .return_value.__enter__.return_value = MagicMock()
    return session


@pytest.fixture
def query(mocker, session):
    """Fixture for query instance."""
    query = session.query.return_value = MagicMock()
    return query


def test_get_phonetic_translations_for_product_without_id(mocker):
    """Test get_phonetic_translations with no id."""
    response = rpt_model.get(None)
    assert response.errors['message'] == (
        'No release_id sent for get phonetic translations.')


def test_get_phonetic_translations_for_product(mocker, query):
    """Test get_phonetic_translations with valid product id."""
    rpt_model.get(1)
    called = query.filter.call_args_list[0][0][0]
    assert ExpressionMatcher(called) == (
        (PhoneticTranslations.release_id == 1))


def test_create_single_phonetic_translation(mocker, query, session):
    """Test create_single_phonetic_translation."""
    query.filter().filter().filter().filter().first.return_value = None
    create_query = session.add = MagicMock()

    data = {
        'field_name': 'field',
        'language_id': 1,
        'release_id': 1,
        'phonetic_translation': 'test'
    }
    rpt_model.create_single_phonetic_translation(data)
    create_query.assert_called_once()


def test_create_single_phonetic_translation_existing_translation(
        mocker, query, session):
    """Test create_single_phonetic_translation when translation exists."""
    get_query = query \
        .filter().filter().filter().filter().first.return_value = MagicMock()
    get_query.to_dict.return_value = 'test'
    create_query = session.add = MagicMock()

    data = {
        'field_name': 'field',
        'language_id': 1,
        'release_id': 1,
        'phonetic_translation': 'test'
    }
    result = rpt_model.create_single_phonetic_translation(data)
    assert result == 'test'
    create_query.assert_not_called()


def test_create_phonetic_translations(mocker):
    """Test create."""
    data = ['test_arg_1', 'test_arg_2']
    mock_create_single = \
        rpt_model.create_single_phonetic_translation = MagicMock()

    rpt_model.create(data)
    mock_create_single.assert_any_call(data[0])
    mock_create_single.assert_any_call(data[1])


def test_update_single_phonetic_translation(mocker, query):
    """Test update_single_phonetic_translation."""
    update_query = query.filter().update = MagicMock()

    data = {
        'release_phonetic_translations_id': 1,
        'field_name': 'field',
        'language_id': 1,
        'release_id': 1,
        'phonetic_translation': 'test'
    }
    rpt_model.update_single_phonetic_translation(data)
    update_query.assert_called_once()


def test_update_single_phonetic_translation_without_id(mocker):
    """Test update_single_phonetic_translation."""
    data = {
        'field_name': 'field',
        'language_id': 1,
        'release_id': 1,
        'phonetic_translation': 'test'
    }
    result = rpt_model.update_single_phonetic_translation(data)
    assert not result


def test_update_phonetic_translations(mocker):
    """Test update_phonetic_translations."""
    data = ['test_arg_1', 'test_arg_2']
    original_function = rpt_model.update_single_phonetic_translation
    mock_create_single = \
        rpt_model.update_single_phonetic_translation = MagicMock()

    rpt_model.update(data)
    mock_create_single.assert_any_call(data[0])
    mock_create_single.assert_any_call(data[1])
    rpt_model.update_single_phonetic_translation = original_function


def test_delete_phonetic_translations_without_id(mocker):
    """Test delete_phonetic_translations with no id."""
    response = rpt_model.delete(None)
    assert response.errors['message'] == (
        'Please provide a list of release_phonetic_translation_ids.')


def test_delete_phonetic_translations_no_rows_deleted(
        mocker, query):
    """Test delete_phonetic_translations with non existent id."""
    delete_query = query.filter.return_value = MagicMock()
    delete_query.update.return_value = None
    response = rpt_model.delete([1])
    delete_query.update.assert_called_once()
    assert response.message == ('0 phonetic translations deleted.')


def test_delete_phonetic_translations_(mocker):
    """Test delete_phonetic_translations with valid id."""
    original_function = rpt_model.delete_single_phonetic_translation
    rpt_model.delete_single_phonetic_translation = \
        MagicMock(side_effect=[True, None, True])

    response = rpt_model.delete([1, 2, 3])
    assert response.message == ('2 phonetic translations deleted.')
    assert rpt_model.delete_single_phonetic_translation.call_count == 3
    rpt_model.delete_single_phonetic_translation = original_function


def test_delete_single_phonetic_translation(mocker, query):
    """Test delete_phonetic_translations with valid id."""
    delete_query = query.filter.return_value = MagicMock()
    delete_query.update.return_value = 1
    response = rpt_model.delete_single_phonetic_translation(1)
    called = query.filter.call_args_list[0][0][0]
    assert ExpressionMatcher(called) == (
        PhoneticTranslations.release_phonetic_translations_id == 1)
    assert response is True
    delete_query.update.assert_called_once()


def test_delete_single_phonetic_translation_invalid_data():
    """Test delete_phonetic_translation with invalid data."""
    response = rpt_model.delete_single_phonetic_translation(None)
    assert response is None


def test_delete_single_phonetic_translation_no_rows_deleted(
        mocker, query):
    """Test delete_single_phonetic_translations no rows deleted."""
    delete_query = query.filter.return_value = MagicMock()
    delete_query.update.return_value = None
    response = rpt_model.delete_single_phonetic_translation(1)
    delete_query.update.assert_called_once()
    assert response is None


def test_delete_by_product_id(mocker, query):
    """Test delete_by_product_id."""
    filter_by_product_id = query.filter.return_value = MagicMock()
    filter_by_is_deleted = \
        filter_by_product_id.filter.return_value = MagicMock()
    filter_by_is_deleted.update.return_value = 2

    response = rpt_model.delete_by_product_id(1)
    filter_by_is_deleted.update.assert_called_once()
    assert response.message == '2 phonetic translations deleted.'


@pytest.mark.parametrize(
    ('data, missing_fields'),
    [
        (
            {
                'field_name': 'field',
                'language_id': 1,
                'release_id': 1
            },
            ['phonetic_translation']
        ),
        (
            {
                'language_id': 1,
                'phonetic_translation': 'translation',
                'release_id': 1
            },
            ['field_name']
        ),
        (
            {
                'field_name': 'field',
                'phonetic_translation': 'translation',
                'release_id': 1
            },
            ['language_id']
        ),
        (
            {
                'field_name': 'field',
                'language_id': 1,
                'phonetic_translation': 'translation'
            },
            ['release_id']
        ),
        (
            {'language_id': 1},
            [
                'field_name',
                'phonetic_translation',
                'release_id'
            ]
        )
    ],
)
def test_create_missing_fields_response(data, missing_fields, mocker):
    """Tests create_missing_fields_response."""
    response = rpt_model.create_missing_fields_response(data)
    assert response.errors['message'] == (
        'The following fields are required: {}'.format(missing_fields))