"""Contract Term Condition functional tests."""

from tests.utils.factories import AccountContractFactory
from tests.utils.factories import ContractFactory
from tests.utils.factories import ContractTermConditionFactory
from tests.utils.factories import ContractTermFactory


def test_create_contract_term_conditions_success(fixture_client):
    """POST /contract-term/<int:contract_term_id>/conditions."""
    contract_term = ContractTermFactory.create()
    json_body = [
        {
            'priority': 1,
            'term_rate': 80.0,
            'conditions': {
                'countries': ['USA'],
                'stores': ['some-store-1', 'some-another'],
                'transaction_types': ['type-1', 'type-1-1']
            },
            'contract_term_condition_name': 'test condition name 1'
        },
        {
            'priority': 2,
            'term_rate': 60.0,
            'conditions': {
                'countries': ['UK'],
                'stores': ['store-1', 'store-2'],
                'transaction_types': ['type-1-2']
            },
            'contract_term_condition_name': 'test condition name 2'
        },
        {
            'priority': 3,
            'term_rate': 70.0,
            'commission': 30.0,
            'conditions': {
                'countries': ['AUS'],
                'stores': ['store-3', 'store-4'],
                'transaction_types': ['type-1-2']
            }
        },
        {
            'priority': 4,
            'commission': 46.40,
            'conditions': {
                'countries': ['CAN'],
                'stores': ['store-5', 'store-6'],
                'transaction_types': ['type-1-2']
            }
        }
    ]
    result = fixture_client.post(
        f'/contract-term/{contract_term.contract_term_id}/conditions',
        json=json_body
    )
    assert result.status_code == 201
    assert result.json == [
        {
            'conditions': {
                'transaction_types': [
                    'type-1',
                    'type-1-1'
                ],
                'stores': [
                    'some-store-1',
                    'some-another'
                ],
                'countries': [
                    'USA'
                ]
            },
            'contract_term_condition_id': 1,
            'term_rate': '80.00',
            'commission': '20.00',
            'priority': 1,
            'contract_term_id': 1,
            'contract_term_condition_name': 'test condition name 1'
        },
        {
            'conditions': {
                'transaction_types': [
                    'type-1-2'
                ],
                'stores': [
                    'store-1',
                    'store-2'
                ],
                'countries': [
                    'UK'
                ]
            },
            'contract_term_condition_id': 2,
            'term_rate': '60.00',
            'commission': '40.00',
            'priority': 2,
            'contract_term_id': 1,
            'contract_term_condition_name': 'test condition name 2'
        },
        {
            'conditions': {
                'transaction_types': [
                    'type-1-2'
                ],
                'stores': [
                    'store-3',
                    'store-4'
                ],
                'countries': [
                    'AUS'
                ]
            },
            'contract_term_condition_id': 3,
            'term_rate': '70.00',
            'commission': '30.00',
            'priority': 3,
            'contract_term_id': 1,
            'contract_term_condition_name': None
        },
        {
            'conditions': {
                'transaction_types': [
                    'type-1-2'
                ],
                'stores': [
                    'store-5',
                    'store-6'
                ],
                'countries': [
                    'CAN'
                ]
            },
            'contract_term_condition_id': 4,
            'term_rate': '53.60',
            'commission': '46.40',
            'priority': 4,
            'contract_term_id': 1,
            'contract_term_condition_name': None
        }
    ]


def test_create_contract_term_conditions_invalid_total(fixture_client):
    """Test creating contract term conditions.

    when sum of commission and term_rate is not equal to 100.
    """
    contract_term = ContractTermFactory.create()
    json_body = [{
        'priority': 1,
        'term_rate': 100.0,
        'commission': 20.0,
        'conditions': {
            'countries': ['USA'],
            'stores': ['some-store-1', 'some-another'],
            'transaction_types': ['type-1', 'type-1-1']
        }
    }]
    result = fixture_client.post(
        f'/contract-term/{contract_term.contract_term_id}/conditions',
        json=json_body
    )
    assert result.status_code == 400
    assert result.json['message']['0'] == \
        {'_schema': ['The sum of commissions and term_rate should be 100.']}


def test_create_contract_term_conditions_missing_fields(fixture_client):
    """Test creating contract term conditions.

    when commission and term_rate fields are missing in the POST request body.
    """
    contract_term = ContractTermFactory.create()
    json_body = [{
        'priority': 1,
        'conditions': {
            'countries': ['USA'],
            'stores': ['some-store-1', 'some-another'],
            'transaction_types': ['type-1', 'type-1-1']
        }
    }]
    result = fixture_client.post(
        f'/contract-term/{contract_term.contract_term_id}/conditions',
        json=json_body
    )
    assert result.status_code == 400
    assert result.json['message']['0'] == \
        {'_schema': ['Both the term rate and commission cannot be blank.']}


def test_create_contract_term_conditions_invalid_commission(fixture_client):
    """Test creating contract term conditions.

    when commission value is not within the range of 0 to 100.
    """
    contract_term = ContractTermFactory.create()
    json_body = [{
        'priority': 1,
        'commission': 120,
        'conditions': {
            'countries': ['USA'],
            'stores': ['some-store-1', 'some-another'],
            'transaction_types': ['type-1', 'type-1-1']
        }
    }]
    result = fixture_client.post(
        f'/contract-term/{contract_term.contract_term_id}/conditions',
        json=json_body
    )
    assert result.status_code == 400
    assert result.json['message']['0'] == \
        {'commission': ['Must be greater than or equal to 0.0 and less than or equal to 100.0.']}  # noqa:E501


def test_get_conditions_by_contract_term(fixture_client, create_mock_account):
    """Test updating one or more contract_term_conditions."""
    contract = ContractFactory.create()
    AccountContractFactory.create(contract=contract)
    contract_term = ContractTermFactory.create(contract=contract)
    contract_term_conditions = ContractTermConditionFactory.create_batch(
        3,
        contract_term=contract_term
    )

    result = fixture_client.get(
        f'/contract-term/{contract_term.contract_term_id}/conditions',
    )

    assert result.status_code == 200
    assert len(result.json) == len(contract_term_conditions)


def test_soft_delete_contract_term_conditions_success(fixture_client):
    """Test soft deleting one or more contract_term_conditions."""
    contract_term = ContractTermFactory.create()
    contract_term_conditions = [
        ContractTermConditionFactory.create(
            contract_term=contract_term,
            priority=priority
        ) for priority in [1, 2, 3]
    ]
    contract_term_condition_ids = [
        condition.contract_term_condition_id for condition in contract_term_conditions
    ]

    result = fixture_client.put(
        '/contract-term-conditions/soft-delete',
        json=contract_term_condition_ids[:2]
    )

    assert result.status_code == 200
    for contract_term_condition in contract_term_conditions[:2]:
        assert contract_term_condition.deleted_at
        assert contract_term_condition.deleted_by


def test_soft_delete_contract_term_conditions_reprioritizes_conditions(fixture_client):
    """Soft delete reprioritizes remaining contract term conditions."""
    contract_term = ContractTermFactory.create()
    contract_term_conditions = [
        ContractTermConditionFactory.create(
            contract_term=contract_term,
            priority=priority
        ) for priority in [1, 2, 3]
    ]
    contract_term_condition_ids = [
        condition.contract_term_condition_id for condition in contract_term_conditions
    ]

    result = fixture_client.put(
        '/contract-term-conditions/soft-delete',
        json=contract_term_condition_ids[:1]
    )

    assert result.status_code == 200
    assert contract_term_conditions[1].priority == 1
    assert contract_term_conditions[2].priority == 2


def test_soft_delete_contract_term_condition_error(fixture_client):
    """Soft deleting returns error if result is no active contract term conditions."""
    contract_term_condition = ContractTermConditionFactory.create()
    res = fixture_client.put(
        '/contract-term-conditions/soft-delete',
        json=[contract_term_condition.contract_term_condition_id]
    )

    assert res.status_code == 400
    assert not contract_term_condition.deleted_at
    assert not contract_term_condition.deleted_by


def test_update_contract_term_conditions_success(fixture_client):
    """Test updating one or more contract_term_conditions."""
    contract_term = ContractTermFactory.create()
    contract_term_conditions = [
        ContractTermConditionFactory.create(
            contract_term=contract_term,
            priority=priority
        ) for priority in [1, 2, 3]
    ]

    json_body = [{
        'contract_term_condition_id': condition.contract_term_condition_id,
        'conditions': condition.conditions,
        'priority': condition.priority,
        'term_rate': 20.20
    } for condition in contract_term_conditions]

    result = fixture_client.put(
        f'/contract-term/{contract_term.contract_term_id}/conditions',
        json=json_body
    )

    assert result.status_code == 200
    assert len(result.json) == len(json_body)
    for condition in contract_term_conditions:
        assert str(condition.term_rate) == '20.20'
        assert str(condition.commission) == '79.80'


def test_update_contract_term_conditions_for_commision(fixture_client):
    """Test to update commission field."""
    contract_term = ContractTermFactory.create()
    contract_term_conditions = [
        ContractTermConditionFactory.create(
            contract_term=contract_term,
            priority=priority
        ) for priority in [1, 2, 3]
    ]

    json_body = [{
        'contract_term_condition_id': condition.contract_term_condition_id,
        'commission': 13.09
    } for condition in contract_term_conditions]

    result = fixture_client.put(
        f'/contract-term/{contract_term.contract_term_id}/conditions',
        json=json_body
    )

    assert result.status_code == 200
    assert len(result.json) == len(json_body)
    for condition in contract_term_conditions:
        assert str(condition.term_rate) == '86.91'
        assert str(condition.commission) == '13.09'


def test_update_contract_term_conditions_invalid_total(fixture_client):
    """Test updating commission and term_rate fields when total is not 100."""
    contract_term = ContractTermFactory.create()
    contract_term_conditions = [
        ContractTermConditionFactory.create(
            contract_term=contract_term,
            priority=priority
        ) for priority in [1, 2, 3]
    ]

    json_body = [{
        'contract_term_condition_id': condition.contract_term_condition_id,
        'commission': 80,
        'term_rate': 30
    } for condition in contract_term_conditions]

    result = fixture_client.put(
        f'/contract-term/{contract_term.contract_term_id}/conditions',
        json=json_body
    )

    assert result.status_code == 400
    assert result.json['message']['0'] == \
        {'_schema': ['The sum of commissions and term_rate should be 100.']}


def test_update_contract_term_conditions_invalid_term_rate(fixture_client):
    """Test updating term_rate field when value is not within range of 0 to 100."""
    contract_term = ContractTermFactory.create()
    contract_term_conditions = [
        ContractTermConditionFactory.create(
            contract_term=contract_term,
            priority=priority
        ) for priority in [1, 2, 3]
    ]

    json_body = [{
        'contract_term_condition_id': condition.contract_term_condition_id,
        'term_rate': 130
    } for condition in contract_term_conditions]

    result = fixture_client.put(
        f'/contract-term/{contract_term.contract_term_id}/conditions',
        json=json_body
    )

    assert result.status_code == 400
    assert result.json['message']['0'] == \
        {'term_rate': ['Must be greater than or equal to 0.0 and less than or equal to 100.0.']}  # noqa:E501


def test_update_contract_term_conditions_invalid_condition_id(fixture_client):
    """Updating one or more contract_term_conditions fails with invalid condition."""
    contract_term = ContractTermFactory.create()
    contract_term_conditions = ContractTermConditionFactory.create_batch(
        2,
        contract_term=contract_term
    )
    json_body = [{
        'contract_term_condition_id': condition.contract_term_condition_id + 2,
        'conditions': condition.conditions,
        'priority': condition.priority,
        'term_rate': 20.20
    } for condition in contract_term_conditions]

    result = fixture_client.put(
        f'/contract-term/{contract_term.contract_term_id}/conditions',
        json=json_body
    )

    assert result.status_code == 400
    assert result.json['code'] == 'error'