"""Tests for contract template logic."""

from unittest.mock import patch

from abacus_common_logic.utils.dates import current_timestamp
from owsresponse import response

from abacus_contract.constants.constants import \
    CONTRACT_LIFECYCLE_SCHEDULE_RENEWAL_TYPES
from abacus_contract.constants.constants import CONTRACT_TERM_TYPES
from abacus_contract.constants.constants import CONTRACT_TYPES
from abacus_contract.logic import contract_template as logic
from abacus_contract.utils.format_error import validation_error
from tests.utils.factories import ContractTemplateFactory


@patch('abacus_contract.logic.contract_template.create_contract_terms_and_conditions')
@patch('abacus_contract.logic.contract_template.contract_exclusion')
@patch('abacus_contract.logic.contract_template.create_contract')
@patch('abacus_contract.logic.contract_template.models')
def test_create_contract_from_template_id(
    mock_models,
    mock_create_contract_method,
    mock_contract_exclusion_logic,
    mock_create_contract_terms_and_conditions_method,
    create_mock_account,
    create_mock_run_controller
):
    """Test creating contract from contract_template_id."""
    contract_template = ContractTemplateFactory.create(
        contract_type=CONTRACT_TYPES.DISTRIBUTION
    )
    contract_template_id = contract_template.contract_template_id
    params = {'account_id': 1, 'account_name': 'AWAL GDA'}
    new_contract_id = 123

    mock_models.ContractTemplate.get_by_id_or_error.return_value = contract_template

    mock_create_contract_method.return_value.status = 201
    mock_create_contract_method.return_value.message = {'contract_id': new_contract_id}
    mock_contract_exclusion_logic.get_exclusions_by_contract.return_value = None
    mock_create_contract_terms_and_conditions_method.return_value.status = 201

    res = logic.create_contract_from_template_id(contract_template_id, params)
    assert res.status == 201
    mock_create_contract_method.assert_called_once_with(params, contract_template)
    mock_contract_exclusion_logic.get_exclusions_by_contract.assert_called_once_with(
        new_contract_id
    )
    mock_create_contract_terms_and_conditions_method.assert_called_once()


@patch('abacus_contract.logic.contract_template.create_contract')
@patch('abacus_contract.logic.contract_template.models')
def test_create_contract_from_template_id_error(
    mock_models,
    mock_create_contract_method,
    create_mock_run_controller
):
    """Test Error while creating contract."""
    contract_template = ContractTemplateFactory.create()
    contract_template_id = contract_template.contract_template_id
    params = {'account_id': 123, 'account_name': 'AWAL GDA'}
    mock_models.ContractTemplate.get_by_id_or_error.return_value = contract_template
    mock_create_contract_method.return_value = validation_error('error')

    res = logic.create_contract_from_template_id(contract_template_id, params)

    assert res.status == 400
    assert res.errors['message'] == 'error'


@patch('abacus_contract.logic.contract_template.contract_term')
def test_create_contract_terms_and_conditions(
    mock_contract_term_logic,
    create_mock_run_controller
):
    """Test creating contract terms and conditions."""
    contract_template = ContractTemplateFactory.create()
    contract_details = {'contract_id': 1, 'account_id': 1}
    mock_contract_term_logic.bulk_create_contract_terms_and_conditions.return_value = \
        response.Response(message='OK', status=201)
    res = \
        logic.create_contract_terms_and_conditions(contract_details, contract_template)

    assert res.status == 201
    mock_contract_term_logic.bulk_create_contract_terms_and_conditions.assert_called_once()  # noqa: E501


@patch('abacus_contract.logic.contract_template.contract_term')
def test_create_contract_terms_and_conditions_error(
    mock_contract_term_logic,
    create_mock_run_controller
):
    """Test validation raises error when attachments field is missing."""
    contract_terms = [{
        'conditions': {
            'stores': [],
            'priority': 1,
            'countries': [],
            'term_rate': '80.00',
            'transaction_types': []
        },
        'is_base_term': True,
        'term_type': CONTRACT_TERM_TYPES.LABEL
    }]
    contract_template = ContractTemplateFactory.create(contract_terms=contract_terms)
    contract_details = {'contract_id': 1}
    res = \
        logic.create_contract_terms_and_conditions(contract_details, contract_template)

    assert res.status == 400
    mock_contract_term_logic.bulk_create_contract_terms_and_conditions.assert_not_called()  # noqa: E501


@patch('abacus_contract.logic.contract_template.contract')
def test_create_contract(
    mock_contract_logic,
    create_mock_run_controller
):
    """Test create_contract when."""
    account_params = {
        'account_id': 1,
        'account_name': 'Test Name'
    }
    contract_template = ContractTemplateFactory.create(term_duration_year=None)

    logic.create_contract(account_params, contract_template)

    mock_contract_logic.create_contract_with_lifecycle_and_schedules \
        .assert_called_once_with(
            contract=dict(
                account_id=account_params.get('account_id'),
                contract_name=account_params.get('account_name'),
                contract_type=contract_template.contract_type,
                reference_signing_entity_id=contract_template.reference_signing_entity_id,  # noqa: E501
                contract_exclusions=contract_template.contract_exclusions
            ),
            contract_lifecycle=dict(
                lifecycle_term_start=current_timestamp().date()
            ),
            contract_lifecycle_schedules=[dict(
                renewal_type=CONTRACT_LIFECYCLE_SCHEDULE_RENEWAL_TYPES.CONTINUOUSLY_ACTIVE,  # noqa: E501
                termination_notice_detail_interval=30,
                termination_notice_detail_type='day'
            )]
        )