"""Tests for Instant Grat Persister."""
from datetime import datetime

from oto import status as response_code
import pytest

from backend.constants import error
from backend.models.instant_grats_persister import InstantGratPersister
from tests.testutils import db


@pytest.fixture
def instant_grat_create_data():
    """Return a valid data for Instant Grat creating."""
    return {
        'tuid': 1,
        'store_id': 1,
        'date': datetime(year=2018, month=5, day=20),
        'user_id': 25824,
        'user_type': 'alw'
    }


@pytest.fixture
def existing_instant_grats(instant_grat_factory):
    """Return list of existing instant grats."""
    return [
        instant_grat_factory(tuid=1, user_id='25824', user_type='oa'),
        instant_grat_factory(tuid=2, user_id='25824', user_type='oa'),
        instant_grat_factory(tuid=3, user_id='25824', user_type='oa')]


@db.test_schema_no_seed
@pytest.mark.parametrize(
    'query_tuids, existing_grats, expected_fetch_result_count',
    [
        ([1, 2, 3],
         [{'tuid': 1, 'store_id': 1},
          {'tuid': 2, 'store_id': 1},
          {'tuid': 3, 'store_id': 1}],
         3),
        ([1, 2, 3],
         [{'tuid': 1, 'store_id': 1},
          {'tuid': 2, 'store_id': 1},
          {'tuid': 3, 'store_id': 1},
          {'tuid': 1, 'store_id': 2},
          {'tuid': 2, 'store_id': 2},
          {'tuid': 3, 'store_id': 2}
          ],
         6),
        ([1, 2, 3],
         [{'tuid': 1, 'store_id': 1},
          {'tuid': 2, 'store_id': 1},
          {'tuid': 1, 'store_id': 2},
          {'tuid': 2, 'store_id': 2}
          ],
         4)
    ])
def test_fetch_instant_grats_by_list_of_tuids(
        query_tuids, existing_grats, expected_fetch_result_count,
        instant_grat_factory):
    """Test fetch instant grats by tuids success."""
    user_id = '25824'
    user_type = 'oa'
    instant_grats = [
        instant_grat_factory(
            tuid=grat['tuid'], store_id=grat['store_id'], user_id=user_id,
            user_type=user_type)
        for grat in existing_grats]
    db.merge_model_objects(instant_grats)
    result = InstantGratPersister.fetch_grats_by_list_of_tuids(query_tuids)
    assert result
    assert len(result.message) == expected_fetch_result_count


@db.test_schema_no_seed
def test_fetch_instant_grats_by_list_of_tuids_active_filter_enabled(
        instant_grat_factory):
    """Test fetch instant grats by tuids with active_only filter enabled."""
    user_id = '25824'
    user_type = 'oa'
    tuid = 1
    active_grat = instant_grat_factory(
        tuid=tuid, store_id=1, user_id=user_id, user_type=user_type,
        active='Y')
    inactive_grat = instant_grat_factory(
        tuid=tuid, store_id=1, user_id=user_id, user_type=user_type,
        active='N')
    instant_grats = [active_grat, inactive_grat]
    db.merge_model_objects(instant_grats)
    expected_fetch_result = [active_grat.to_dict()]
    result = InstantGratPersister.fetch_grats_by_list_of_tuids(
        [tuid], active_only=True)
    assert result
    assert result.message == expected_fetch_result


@db.test_schema_no_seed
def test_fetch_instant_grats_by_list_of_tuids_active_filter_disabled(
        instant_grat_factory):
    """Test fetch instant grats by tuids returns grats (includes inactive)."""
    user_id = '25824'
    user_type = 'oa'
    tuid = 1
    active_grat = instant_grat_factory(
        tuid=tuid, store_id=1, user_id=user_id, user_type=user_type,
        active='Y')
    inactive_grat = instant_grat_factory(
        tuid=tuid, store_id=1, user_id=user_id, user_type=user_type,
        active='N')
    instant_grats = [active_grat, inactive_grat]
    db.merge_model_objects(instant_grats)
    expected_fetch_result = [active_grat.to_dict(), inactive_grat.to_dict()]
    result = InstantGratPersister.fetch_grats_by_list_of_tuids(
        [tuid], active_only=False)
    assert result
    assert result.message == expected_fetch_result


@db.test_schema_no_seed
def test_fetch_instant_grats_by_list_of_tuids_not_found():
    """Test fetch instant grats by tuids not found."""
    tuids = [1, 9, 296]
    result = InstantGratPersister.fetch_grats_by_list_of_tuids(tuids)
    assert not result
    assert result.errors['message'] == error.INSTANT_GRATS_NOT_FOUND_MSG


@pytest.mark.parametrize(
    'grats_count', (1, 5))
@db.test_schema_no_seed
def test_bulk_create_grats(grats_count, instant_grat_create_data):
    """Test bulk create grats successful result."""
    tuids = []
    grats = []
    for tuid in range(1, grats_count + 1):
        grat = instant_grat_create_data.copy()
        grat['tuid'] = tuid
        tuids.append(tuid)
        grats.append(grat)

    created_grats = InstantGratPersister.bulk_create_grats(grats)
    fetched_grats = InstantGratPersister.fetch_grats_by_list_of_tuids(tuids)
    assert created_grats
    assert created_grats.status == response_code.CREATED
    assert len(fetched_grats.message) == grats_count


@db.test_schema_no_seed
def test_bulk_create_grats_unexpected_field_provided(instant_grat_create_data):
    """Test bulk create grats failed due to extra fields provided."""
    grat = instant_grat_create_data.copy()
    tuid = grat.get('tuid')
    grat['extra_field'] = 'I should not be here!!!'
    grats = [grat]
    created_grats = InstantGratPersister.bulk_create_grats(grats)
    assert not created_grats
    assert created_grats.errors['message'] == (
        '`extra_field` field cannot be set using this endpoint')
    fetched_grats = InstantGratPersister.fetch_grats_by_list_of_tuids(
        [tuid])
    assert not fetched_grats


@db.test_schema_no_seed
def test_bulk_update_grats(existing_instant_grats):
    """Test bulk update grats for successful result."""
    changed_date = datetime(year=2020, month=6, day=21)
    db.merge_model_objects(existing_instant_grats)
    expected_result = []
    for instant_grat in existing_instant_grats:
        instant_grat.date = changed_date
        expected_result.append(instant_grat.to_dict())
    grats_update_data = [
        {'tuid': grat.tuid, 'store_id': grat.store_id, 'date': changed_date}
        for grat in existing_instant_grats]
    tuids = [grat.tuid for grat in existing_instant_grats]
    result = InstantGratPersister.bulk_update_grats(tuids, grats_update_data)
    assert result.message.get('items') == expected_result


@db.test_schema_no_seed
def test_bulk_update_grats_removed_unnecessary_grat(existing_instant_grats):
    """Test bulk update grats for successful result one less grats provided."""
    changed_date = datetime(year=2020, month=6, day=21)
    db.merge_model_objects(existing_instant_grats)
    expected_result = []
    removed_grat_tuid = 1
    for instant_grat in existing_instant_grats:
        instant_grat.date = changed_date
        if instant_grat.tuid != removed_grat_tuid:
            expected_result.append(instant_grat.to_dict())
    grats_update_data = [
        {'tuid': grat.tuid, 'store_id': grat.store_id, 'date': changed_date}
        for grat in existing_instant_grats if grat.tuid != removed_grat_tuid]
    tuids = [grat.tuid for grat in existing_instant_grats]
    result = InstantGratPersister.bulk_update_grats(tuids, grats_update_data)
    assert result.message.get('items') == expected_result


@db.test_schema_no_seed
def test_bulk_update_grats_new_grat_provided(existing_instant_grats):
    """Test bulk update grats for successful result create extra grat."""
    changed_date = datetime(year=2020, month=6, day=21)
    db.merge_model_objects(existing_instant_grats)

    extra_grat = {
        'tuid': 991, 'store_id': 3, 'created_by': '', 'active': 'Y',
        'date': datetime(year=2020, month=5, day=20)}

    expected_result = []
    for instant_grat in existing_instant_grats:
        instant_grat.date = changed_date
        expected_result.append(instant_grat.to_dict())

    grats_update_data = [
        {'tuid': grat.tuid, 'store_id': grat.store_id, 'date': changed_date}
        for grat in existing_instant_grats]
    grats_update_data.append(
        {'tuid': 991, 'store_id': 3,
         'date': datetime(year=2020, month=5, day=20)})

    tuids = [grat.tuid for grat in existing_instant_grats]
    result = InstantGratPersister.bulk_update_grats(tuids, grats_update_data)
    created_at = [
        res['created_at'] for res in result.message.get('items')
        if res['tuid'] == extra_grat['tuid']][0]
    extra_grat['created_at'] = created_at
    expected_result.append(extra_grat)
    assert result.message.get('items') == expected_result


@db.test_schema_no_seed
def test_bulk_update_grats_not_allowed_field_provided(existing_instant_grats):
    """Test bulk update grats for 400 error not allowed field provided."""
    changed_date = datetime(year=2020, month=6, day=21)
    not_allowed_field = 'created_at'
    db.merge_model_objects(existing_instant_grats)
    expected_result = []
    for instant_grat in existing_instant_grats:
        instant_grat.date = changed_date
        expected_result.append(instant_grat.to_dict())
    grats_update_data = [
        {'tuid': grat.tuid, 'store_id': grat.store_id, 'date': changed_date,
         not_allowed_field: 'Not allowed'}
        for grat in existing_instant_grats]
    tuids = [grat.tuid for grat in existing_instant_grats]
    result = InstantGratPersister.bulk_update_grats(tuids, grats_update_data)
    assert not result
    assert result.errors['code'] == error.VALIDATION_ERROR_CODE
    assert result.errors['message'] == (
        error.VALIDATION_ERROR_SUPERFLUOUS_FIELD_MSG.format(
            not_allowed_field))