"""Test for split_rules module."""

from datetime import date
from unittest.mock import Mock

import pytest

from flows.cable_calculation import splits


@pytest.fixture
def fixture_split_rule_definition():
    """Sample store list."""
    return splits.SplitRuleDefinition({
        'foo': {'type': str},
        'bar': {'type': int}
        },
        lambda x: x # noqa
    )


"""-----------------------
Tests for SplitRule class.
-----------------------"""


def test_init_split_rule():
    """Test SplitRule constructor."""
    rule_id = 'foo'
    rule_store_id = 111
    rule_start = date(2015, 3, 25)
    rule_definition = Mock()
    rule_terminated = False

    split_rule = splits.SplitRule(
        rule_id, rule_store_id, rule_start, rule_definition, rule_terminated)

    assert split_rule.id is rule_id
    assert split_rule.store_id is rule_store_id
    assert split_rule.start is rule_start
    assert split_rule.rule_definition is rule_definition
    assert split_rule.terminated is rule_terminated


def test_apply(monkeypatch):
    """Test SplitRule constructor."""
    rule_definition = Mock()
    rule_definition_execute_mock = Mock(return_value='foo')
    monkeypatch.setattr(
        rule_definition,
        'execute', rule_definition_execute_mock)

    apply_args = dict(sample='hey')

    split_rule = splits.SplitRule(
        'foo', 111, date(2015, 3, 25), rule_definition, False)

    result = split_rule.apply(**apply_args)

    rule_definition_execute_mock.assert_called_with(**apply_args)

    assert result == 'foo'


"""---------------------------------
Tests for SplitRuleDefinition class.
---------------------------------"""


def test_init_split_rule_definition():
    """Test SplitRuleDefinition constructor."""
    schema = {'foo': 'bar'}
    rule_callable = lambda x: x  # noqa

    rule_definition = splits.SplitRuleDefinition(schema, rule_callable)

    assert rule_definition.schema == schema
    assert rule_definition.rule_callable is rule_callable


def test_validate_param_schema(fixture_split_rule_definition):
    """Test validating param type with valid schema."""
    schema = {
        'foo': 'hi there!',
        'bar': 123
    }

    fixture_split_rule_definition.validate_param_schema(**schema)

    # the tested function contains assertions
    assert True


def test_validate_param_schema_missing_param(fixture_split_rule_definition):
    """Test validating param with missing param."""
    schema = {
        # 'foo' missing
        'bar': 123
    }

    with pytest.raises(AssertionError) as error_info:
        fixture_split_rule_definition.validate_param_schema(**schema)

    assert 'Missing param: \'foo\'' in str(error_info.value)


def test_validate_param_schema_invalid_type(fixture_split_rule_definition):
    """Test validating param type with invalid param type."""
    schema = {
        # 'foo' has wrong type
        'foo': 0.1211,
        'bar': 123
    }

    with pytest.raises(AssertionError) as error_info:
        fixture_split_rule_definition.validate_param_schema(**schema)

    assert 'Wrong type for param \'foo\'' in str(error_info.value)


def test_validate_param_values_not_implemented(fixture_split_rule_definition):
    """Test implementation of the validate_param_values function."""
    params = {
        'foo': 'blah',
        'bar': 123
    }

    with pytest.raises(NotImplementedError):
        fixture_split_rule_definition.validate_param_values(**params)

    assert True


def test_validate_params(monkeypatch, fixture_split_rule_definition):
    """Test validating param type with invalid param type."""
    params = {'foo': 'bar'}

    check_schema_mock = Mock()
    check_values_mock = Mock()
    monkeypatch.setattr(
        fixture_split_rule_definition,
        'validate_param_schema', check_schema_mock)
    monkeypatch.setattr(
        fixture_split_rule_definition,
        'validate_param_values', check_values_mock)

    fixture_split_rule_definition.validate_params(**params)

    check_schema_mock.assert_called_with(**params)
    check_values_mock.assert_called_with(**params)


def test_execute(monkeypatch, fixture_split_rule_definition):
    """Test executing the rule with params."""
    params = {'foo': 'bar'}

    validate_params_mock = Mock()
    callable_mock = Mock()
    monkeypatch.setattr(
        fixture_split_rule_definition,
        'validate_params', validate_params_mock)
    monkeypatch.setattr(
        fixture_split_rule_definition,
        'rule_callable', callable_mock)

    fixture_split_rule_definition.execute(**params)

    validate_params_mock.assert_called_with(**params)
    callable_mock.assert_called_with(**params)


"""--------------------------
Tests for SplitRuleDbo class.
--------------------------"""


def test_init_split_rule_dbo():
    """Test SplitRuleDbo constructor."""
    expected_schema = {'dbo': {'type': float}}
    rule_callable = lambda x: x  # noqa

    rule_definition = splits.SplitRuleDbo(rule_callable)

    assert rule_definition.rule_callable is rule_callable
    assert rule_definition.schema == expected_schema


def test_split_rule_dbo_validate_param_values():
    """Test validate_param_values method."""
    rule_callable = lambda x: x  # noqa

    rule_definition = splits.SplitRuleDbo(rule_callable)

    rule_definition.validate_param_values(dbo=5000)
    # the tested function contains assertions
    assert True


def test_split_rule_dbo_validate_param_values_invalid():
    """Test validate_param_values method with invalid param value."""
    rule_callable = lambda x: x  # noqa

    rule_definition = splits.SplitRuleDbo(rule_callable)

    with pytest.raises(AssertionError):
        rule_definition.validate_param_values(dbo=-3000)

    assert True


"""-------------------------------
Tests for SplitRuleDboDates class.
-------------------------------"""


def test_init_split_rule_dbo_dates():
    """Test SplitRuleDboDates constructor."""
    expected_schema = {
        'dbo': {'type': float},
        'vod_date': {'type': date},
        'est_date': {'type': date}}
    rule_callable = lambda x: x  # noqa

    rule_definition = splits.SplitRuleDboDates(rule_callable)

    assert rule_definition.rule_callable is rule_callable
    assert rule_definition.schema == expected_schema


def test_split_rule_dbo_dates_validate_param_values():
    """Test validate_param_values method."""
    rule_callable = lambda x: x  # noqa

    rule_definition = splits.SplitRuleDboDates(rule_callable)

    rule_definition.validate_param_values(
        dbo=5000, vod_date=date(2016, 8, 5), est_date=date(2016, 7, 5))
    # the tested function contains assertions
    assert True


def test_split_rule_dbo_dates_validate_param_values_invalid():
    """Test validate_param_values method with invalid param value."""
    rule_callable = lambda x: x  # noqa

    rule_definition = splits.SplitRuleDboDates(rule_callable)

    # invalid DBO value
    with pytest.raises(AssertionError):
        rule_definition.validate_param_values(
            dbo=-3000, vod_date=date(2016, 8, 5), est_date=date(2016, 7, 5))

    # invalid dates
    with pytest.raises(AssertionError):
        rule_definition.validate_param_values(
            dbo=-3000, vod_date=date(2016, 1, 5), est_date=date(2016, 7, 5))

    assert True


"""-------------------------------
Tests for SplitRulePremiumUltra class.
-------------------------------"""


def test_init_split_rule_premium_ultra():
    """Test SplitRulePremiumUltra constructor."""
    pass


"""-------------------------------
Tests for SplitRuleStraight class.
-------------------------------"""


def test_init_split_rule_straight():
    """Test SplitRuleStraight constructor."""
    expected_schema = {}
    rule_callable = lambda x: x  # noqa

    rule_definition = splits.SplitRuleStraight(rule_callable)

    assert rule_definition.rule_callable is rule_callable
    assert rule_definition.schema == expected_schema


def test_split_rule_straight_validate_param_values():
    """Test validate_param_values method."""
    rule_callable = lambda x: x  # noqa

    rule_definition = splits.SplitRuleStraight(rule_callable)

    rule_definition.validate_param_values()
    # the tested function contains assertions
    assert True


def test_split_rule_straight_validate_param_values_invalid():
    """Test validate_param_values method with invalid param value."""
    # No params expected so, always True
    assert True