"""Unit Tests for contract_term_schedule logic."""

from unittest.mock import MagicMock, patch

from abacus_contract.logic import contract_term_schedule as logic
from tests.utils.factories import ContractTermFactory
from tests.utils.factories import ContractTermScheduleFactory


@patch('abacus_contract.logic.contract_term_schedule.models')
def test_get_contract_term_schedules_by_term_id(mock_models, create_mock_schedule):
    """Test get_contract_term_schedules_by_term_id function."""
    mock_contract_term = ContractTermFactory.create()
    mock_contract_term_schedule = ContractTermScheduleFactory.create(
        contract_term=mock_contract_term,
        schedule_id=2
    )

    mock_models.ContractTerm.get_by_id_or_error.return_value = mock_contract_term
    mock_models.ContractTermSchedule.get_by_term_id.return_value = \
        [mock_contract_term_schedule]

    contract_term_id = mock_contract_term.contract_term_id

    res = logic.get_contract_term_schedules_by_term_id(contract_term_id)

    assert res.status == 200
    assert res.message == [{
        'contract_term_schedule_id':
            mock_contract_term_schedule.contract_term_schedule_id,
        'contract_term_id': contract_term_id,
        'schedule_id': mock_contract_term_schedule.schedule_id
    }]
    mock_models.ContractTermSchedule.get_by_term_id.assert_called_once_with(contract_term_id)  # noqa:E501


@patch('abacus_contract.logic.contract_term_schedule.models')
def test_create_contract_term_schedules(mock_models, create_mock_schedule):
    """Test create_contract_term_schedules function."""
    mock_contract_term = ContractTermFactory.create()
    schedule_ids = ['1']
    mock_contract_term_schedule = ContractTermScheduleFactory.create(
        contract_term=mock_contract_term,
        schedule_id=schedule_ids[0]
    )
    mock_models.ContractTermSchedule.build.return_value = mock_contract_term_schedule
    mock_models.ContractTermSchedule.commit_changes.return_value = True

    params = {
        'schedule_ids': schedule_ids,
        'contract_term_id': mock_contract_term.contract_term_id
    }

    result = logic.create_contract_term_schedules(**params)

    assert result == [mock_contract_term_schedule]
    assert mock_models.ContractTermSchedule.build.call_count == len(schedule_ids)

    mock_models.ContractTermSchedule.build.assert_called_once_with(
        contract_term_id=mock_contract_term.contract_term_id,
        schedule_id=schedule_ids[0]
    )
    mock_models.ContractTermSchedule.commit_changes.assert_called_once()


@patch('abacus_contract.logic.contract_term_schedule.models')
def test_delete_contract_term_schedules(mock_models, create_mock_schedule):
    """Test delete_or_restore_contract_term_schedules function.

    Existing term schedules will be deleted if related schedule_ids are not
    included in the PUT request.
    """
    mock_contract_term = ContractTermFactory.create()
    schedule_ids = [1, 3]
    mock_contract_term_schedules = dict([(
        schedule_id, ContractTermScheduleFactory.create(
            contract_term=mock_contract_term,
            schedule_id=schedule_id
        )
    ) for schedule_id in schedule_ids])
    mock_contract_term_schedules[1].delete_by_id_or_error = MagicMock()

    params = {
        'existing_schedules': mock_contract_term_schedules,
        'existing_term_schedule_ids': schedule_ids,
        'new_schedule_ids': [3]
    }
    result = logic.delete_or_restore_contract_term_schedules(**params)

    assert not result
    mock_contract_term_schedules[1].delete_by_id_or_error.assert_called_once_with(
        mock_contract_term_schedules[1].contract_term_schedule_id,
        soft_delete=True
    )


@patch('abacus_contract.logic.contract_term_schedule.models')
def test_restore_contract_term_schedules(mock_models, create_mock_schedule):
    """Test delete_or_restore_contract_term_schedules function.

    Term schedules will be added back if they are deleted previously but
    included in the PUT request.
    """
    mock_contract_term = ContractTermFactory.create()
    schedule_ids = [1, 3]
    mock_contract_term_schedules = [ContractTermScheduleFactory.create(
        contract_term=mock_contract_term,
        schedule_id=schedule_id,
        deleted_by=None if schedule_id == 1 else 'test_user',
        deleted_at=None if schedule_id == 1 else '2023-08-21',
    ) for schedule_id in schedule_ids]

    existing_contract_term_schedules = {
        schedule_ids[0]: mock_contract_term_schedules[0],
        schedule_ids[1]: mock_contract_term_schedules[1]
    }
    mock_contract_term_schedules[1].update_attributes = MagicMock()
    mock_models.ContractTermSchedule.commit_changes.return_value = True

    params = {
        'existing_schedules': existing_contract_term_schedules,
        'existing_term_schedule_ids': schedule_ids,
        'new_schedule_ids': [1, 3]
    }
    result = logic.delete_or_restore_contract_term_schedules(**params)

    existing_contract_term_schedules[1].deleted_at = None
    existing_contract_term_schedules[1].deleted_by = None

    assert result == [mock_contract_term_schedules[1]]
    mock_contract_term_schedules[1].update_attributes.assert_called_once_with(
        contract_term_schedule_id=mock_contract_term_schedules[1].contract_term_schedule_id,  # noqa: E501
        deleted_by=None,
        deleted_at=None
    )
    mock_models.ContractTermSchedule.commit_changes.assert_called_once()


@patch('abacus_contract.logic.contract_term_schedule.create_contract_term_schedules')
@patch('abacus_contract.logic.contract_term_schedule.models')
def test_create_or_update_contract_term_schedules(
    mock_models,
    mock_create_contract_term_schedules
):
    """Test create_or_update_contract_term_schedules function for new schedule_ids."""
    mock_contract_term = ContractTermFactory.create()
    schedule_ids = ['1', '2']
    contract_term_id = mock_contract_term.contract_term_id

    mock_models.ContractTerm.get_by_id.return_value = mock_contract_term
    mock_create_contract_term_schedules.return_value = []

    params = {
        'schedule_ids': schedule_ids,
        'contract_term_id': contract_term_id
    }

    result = logic.create_or_update_contract_term_schedules(**params)

    assert result.status == 200
    mock_create_contract_term_schedules.assert_called_once_with(
        schedule_ids,
        contract_term_id
    )


@patch('abacus_contract.logic.contract_term_schedule'
       '.delete_or_restore_contract_term_schedules')
@patch('abacus_contract.logic.contract_term_schedule.models')
def test_create_or_update_contract_term_schedules_existing_schedule_ids(
    mock_models,
    mock_delete_or_restore_contract_term_schedules,
    create_mock_schedule
):
    """Test create_or_update_contract_term_schedules function for existing schedule_ids."""  # noqa: E501
    mock_contract_term = ContractTermFactory.create()
    schedule_ids = ['1', '2']
    contract_term_id = mock_contract_term.contract_term_id
    mock_contract_term_schedules = [ContractTermScheduleFactory.create(
        contract_term=mock_contract_term,
        schedule_id=schedule_id,
    ) for schedule_id in schedule_ids]

    mock_models.ContractTerm.get_by_id.return_value = mock_contract_term
    mock_delete_or_restore_contract_term_schedules.return_value = None

    params = {
        'schedule_ids': ['1'],
        'contract_term_id': contract_term_id
    }

    existing_contract_term_schedules = {
        schedule_ids[0]: mock_contract_term_schedules[0],
        schedule_ids[1]: mock_contract_term_schedules[1]
    }

    result = logic.create_or_update_contract_term_schedules(**params)

    assert result.status == 200
    mock_delete_or_restore_contract_term_schedules.assert_called_once_with(
        existing_contract_term_schedules,
        schedule_ids,
        ['1']
    )