"""Unit tests for contract_lifecycle model."""

import datetime
from unittest.mock import patch

from abacus_contract.constants.constants import CONTRACT_LIFECYCLE_STATUSES
from abacus_contract.models import ContractLifecycle
from tests.utils.factories import ContractFactory
from tests.utils.factories import ContractLifecycleFactory
from tests.utils.factories import ContractLifecycleScheduleFactory


def test_create_contract_lifecycle():
    """Test creating a contract_lifecycle."""
    mock_contract = ContractFactory.create()
    mock_contract_lifecycle_schedule = \
        ContractLifecycleScheduleFactory.create(contract=mock_contract)

    contract_lifecycle_schedule_id = \
        mock_contract_lifecycle_schedule.contract_lifecycle_schedule_id
    args = {
        'contract_id': mock_contract.contract_id,
        'contract_lifecycle_schedule_id': contract_lifecycle_schedule_id,
        'lifecycle_status': CONTRACT_LIFECYCLE_STATUSES.ACTIVE,
        'lifecycle_term_start': datetime.date(2024, 7, 15)
    }
    ContractLifecycle.create(**args)
    res = ContractLifecycle.query.all()

    assert len(res) == 1
    assert res[0].contract_id == mock_contract.contract_id
    assert res[0].contract_lifecycle_schedule_id == contract_lifecycle_schedule_id
    assert res[0].lifecycle_status == CONTRACT_LIFECYCLE_STATUSES.ACTIVE
    assert res[0].lifecycle_term_start == datetime.date(2024, 7, 15)
    assert res[0].lifecycle_term_end is None
    assert res[0].renewal_effective is None
    assert res[0].termination_notice_deadline is None
    assert res[0].termination_notice_received is None


def test_get_by_ids():
    """Test to get contract lifecycles by ids."""
    mock_contract_lifecycle_1 = ContractLifecycleFactory.create()
    mock_contract_lifecycle_2 = ContractLifecycleFactory.create()
    mock_contract_lifecycle_3 = ContractLifecycleFactory.create()
    mock_contract_lifecycle_4 = ContractLifecycleFactory.create(
        deleted_at='2024-07-12',
        deleted_by='Test User'
    )

    ids = [
        mock_contract_lifecycle_1.contract_lifecycle_id,
        mock_contract_lifecycle_2.contract_lifecycle_id,
        mock_contract_lifecycle_3.contract_lifecycle_id,
        mock_contract_lifecycle_4.contract_lifecycle_id
    ]
    result = ContractLifecycle.get_by_ids(ids)
    assert len(result) == 3
    assert all([
        res.contract_lifecycle_id in ids[0:3] for res in result
    ])


def test_get_by_contract_id_and_schedule_id():
    """Test to get contract_lifecycle by contract_id and contract_lifecycle_schedule_id."""  # noqa: E501
    mock_lifecycle = ContractLifecycleFactory.create()
    result = ContractLifecycle.get_by_contract_id_and_schedule_id(
        mock_lifecycle.contract_id,
        mock_lifecycle.contract_lifecycle_schedule_id
    )

    assert result == mock_lifecycle


def test_get_deleted_lifecycle_by_contract_id_and_schedule_id():
    """Test to get deleted contract_lifecycle by contract_id and contract_lifecycle_schedule_id."""  # noqa: E501
    mock_lifecycle = ContractLifecycleFactory.create(
        deleted_by='Test User'
    )
    result = ContractLifecycle.get_by_contract_id_and_schedule_id(
        mock_lifecycle.contract_id,
        mock_lifecycle.contract_lifecycle_schedule_id
    )

    assert result is None


def test_get_by_contract_id():
    """Test to get contract_lifecycle by contract_id."""
    mock_lifecycle = ContractLifecycleFactory.create()
    result = ContractLifecycle.get_by_contract_id(mock_lifecycle.contract_id)

    assert result == mock_lifecycle


def test_get_by_contract_ids():
    """Test to get contract lifecycles by contract ids."""
    mock_contract_lifecycle_1 = ContractLifecycleFactory.create()
    mock_contract_lifecycle_2 = ContractLifecycleFactory.create()
    mock_contract_lifecycle_3 = ContractLifecycleFactory.create()
    mock_contract_lifecycle_4 = ContractLifecycleFactory.create(
        deleted_at='2024-07-12',
        deleted_by='Test User'
    )

    ids = [
        mock_contract_lifecycle_1.contract_id,
        mock_contract_lifecycle_2.contract_id,
        mock_contract_lifecycle_3.contract_id,
        mock_contract_lifecycle_4.contract_id
    ]
    result = ContractLifecycle.get_by_contract_ids(ids)
    assert len(result) == 3
    assert all([
        res.contract_id in ids[0:3] for res in result
    ])


def test_get_deleted_lifecycle_by_contract_id():
    """Test to get deleted contract_lifecycle by contract_id."""
    mock_lifecycle = ContractLifecycleFactory.create(
        deleted_by='Test User'
    )
    result = ContractLifecycle.get_by_contract_id(mock_lifecycle.contract_id)

    assert result is None


def test_get_by_lifecycle_status():
    """Test getting contract_lifecycle by lifecycle_status."""
    init_records = ContractLifecycleFactory.create_batch(
        3,
        lifecycle_status=CONTRACT_LIFECYCLE_STATUSES.INIT
    )
    others = ContractLifecycleFactory.create_batch(
        2,
        lifecycle_status=CONTRACT_LIFECYCLE_STATUSES.INACTIVE
    )
    result = ContractLifecycle.get_by_lifecycle_status(CONTRACT_LIFECYCLE_STATUSES.INIT)

    assert len(result.all()) == len(init_records)
    assert all(
        res.lifecycle_status == CONTRACT_LIFECYCLE_STATUSES.INIT for res in result.all()
    )
    assert all(other not in result.all() for other in others)


def test_get_by_renewal_effective():
    """Test getting 'active' contract_lifecycle records by renewal_effective date."""
    today = datetime.date.today()

    renewing_records = ContractLifecycleFactory.create_batch(
        2,
        lifecycle_status=CONTRACT_LIFECYCLE_STATUSES.ACTIVE,
        renewal_effective=today
    )
    not_active = ContractLifecycleFactory.create(
        lifecycle_status=CONTRACT_LIFECYCLE_STATUSES.INIT,
        renewal_effective=today
    )
    not_renewing = ContractLifecycleFactory.create(
        lifecycle_status=CONTRACT_LIFECYCLE_STATUSES.ACTIVE,
        renewal_effective=None
    )

    items, total_count = ContractLifecycle.get_by_renewal_effective(
        limit=100,
        offset=0,
        renewal_effective=today
    )

    assert len(items) == len(renewing_records)
    assert len(renewing_records) == total_count
    assert all(
        item.lifecycle_status == CONTRACT_LIFECYCLE_STATUSES.ACTIVE for item in items
    )
    assert all(item.renewal_effective == today for item in items)
    assert not_active not in items
    assert not_renewing not in items


def test_get_by_termination_effective_or_collection_end():
    """Test to get contract_lifecycle records by termination_effective or collection_end date."""  # noqa: E501
    today = datetime.date.today()

    terminating_records = ContractLifecycleFactory.create_batch(
        2,
        lifecycle_status=CONTRACT_LIFECYCLE_STATUSES.TO_BE_TERMINATED,
        termination_effective=today
    )
    ContractLifecycleFactory.create_batch(
        2,
        lifecycle_status=CONTRACT_LIFECYCLE_STATUSES.TO_BE_TERMINATED,
        termination_effective=today,
        deleted_by='Test User'
    )
    in_collection_period_records = ContractLifecycleFactory.create_batch(
        2,
        lifecycle_status=CONTRACT_LIFECYCLE_STATUSES.IN_COLLECTION_PERIOD,
        collection_end=today
    )
    ContractLifecycleFactory.create_batch(
        2,
        lifecycle_status=CONTRACT_LIFECYCLE_STATUSES.IN_COLLECTION_PERIOD,
        collection_end=today,
        deleted_by='Test User'
    )
    ContractLifecycleFactory.create(
        lifecycle_status=CONTRACT_LIFECYCLE_STATUSES.ACTIVE
    )

    items, total_count = ContractLifecycle.get_by_termination_effective_or_collection_end(  # noqa: 501
        limit=100,
        offset=0,
        termination_date=today
    )

    records = terminating_records + in_collection_period_records
    lifecycle_status = [
        CONTRACT_LIFECYCLE_STATUSES.IN_COLLECTION_PERIOD,
        CONTRACT_LIFECYCLE_STATUSES.TO_BE_TERMINATED
    ]
    assert items == records
    assert len(records) == total_count
    assert all(
        item.lifecycle_status in lifecycle_status for item in items
    )
    assert all(
        item.termination_effective == today
        or item.collection_end == today
        for item in items
    )
    assert all(item.deleted_by is None for item in items)
    assert all(item.deleted_at is None for item in items)


def get_by_activable():
    """Test getting activable contract_lifecycle records."""
    today = datetime.date.today()

    inactive_records = ContractLifecycleFactory.create_batch(
        3,
        lifecycle_status=CONTRACT_LIFECYCLE_STATUSES.INIT,
        lifecycle_term_start=today

    )
    active_record = ContractLifecycleFactory.create(
        lifecycle_status=CONTRACT_LIFECYCLE_STATUSES.ACTIVE,
        lifecycle_term_start=today
    )

    items, total_count = ContractLifecycle.get_by_activable(
        limit=100,
        offset=0,
        lifecycle_term_start=datetime.date.today()
    )

    assert len(items) == len(inactive_records)
    assert len(inactive_records) == total_count
    assert all(
        item.lifecycle_status == CONTRACT_LIFECYCLE_STATUSES.INIT for item in items
    )
    assert active_record not in items


@patch('abacus_contract.models.contract_lifecycle.g')
def test_bulk_update(mock_g):
    """Test updating one or more contract_lifecycle records."""
    user_id = '123'
    mock_g.user_details = {'id': user_id}
    contract_lifecycles = ContractLifecycleFactory.create_batch(
        2,
        lifecycle_status=CONTRACT_LIFECYCLE_STATUSES.TO_BE_TERMINATED
    )

    assert all(
        contract_lifecycle.lifecycle_status
        == CONTRACT_LIFECYCLE_STATUSES.TO_BE_TERMINATED
        for contract_lifecycle in contract_lifecycles
    )

    contract_lifecycle_records = [
        {
            'contract_lifecycle_id': contract_lifecycles[0].contract_lifecycle_id,
            'lifecycle_status': CONTRACT_LIFECYCLE_STATUSES.TERMINATED
        },
        {
            'contract_lifecycle_id': contract_lifecycles[1].contract_lifecycle_id,
            'lifecycle_status': CONTRACT_LIFECYCLE_STATUSES.IN_COLLECTION_PERIOD
        }
    ]

    ContractLifecycle.bulk_update(contract_lifecycle_records)

    lifecycle_status = [
        CONTRACT_LIFECYCLE_STATUSES.TERMINATED,
        CONTRACT_LIFECYCLE_STATUSES.IN_COLLECTION_PERIOD
    ]

    assert all(
        contract_lifecycle.lifecycle_status in lifecycle_status
        for contract_lifecycle in contract_lifecycles
    )

    assert all(
        contract_lifecycle.last_modified_by == user_id
        for contract_lifecycle in contract_lifecycles
    )