"""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,
    CONTRACT_TERM_TYPES,
    CONTRACT_TYPES,
)
from abacus_contract.logic import contract_template as logic
from abacus_contract.tests.utils.factories import ContractTemplateFactory
from abacus_contract.utils.format_error import validation_error


@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()


@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()


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

    logic.create_contract(params, contract_template)

    mock_contract_logic.create_contract_with_lifecycle_and_schedules.assert_called_once_with(
        contract=dict(
            account_id=params.get('account_id'),
            contract_name=params.get('account_name'),
            contract_type=contract_template.contract_type,
            reference_signing_entity_id=contract_template.reference_signing_entity_id,
            reference_sap_profit_center_id=contract_template.reference_sap_profit_center_id,
            contract_exclusions=contract_template.contract_exclusions,
            is_primary_contract=True,
        ),
        contract_lifecycle=dict(lifecycle_term_start=current_timestamp().date()),
        contract_lifecycle_schedules=[
            dict(
                renewal_type=CONTRACT_LIFECYCLE_SCHEDULE_RENEWAL_TYPES.CONTINUOUSLY_ACTIVE,
                termination_notice_detail_interval=30,
                termination_notice_detail_type='day',
            )
        ],
    )