"""Tests for contract_reserve model."""

from abacus_contract.models.contract_reserve import ContractReserve
from tests.utils.factories import AccountContractFactory
from tests.utils.factories import ContractFactory
from tests.utils.factories import ContractReserveFactory


def test_create_contract_reserve():
    """Test to create contract_reserve record."""
    contract = ContractFactory.create()
    reserve = ContractReserve.create(
        contract_id=contract.contract_id,
        reserve_rate=50,
        reserve_release_offset_in_months=1,
        installments_in_months=2,
        release_schedule=[25, 25]
    )
    result = ContractReserve.query.all()
    assert len(result) == 1
    assert result[0] == reserve


def test_get_by_ids(create_mock_account):
    """Test to get reserves by contract_reserve_ids."""
    contracts = ContractFactory.create_batch(2)

    for contract in contracts:
        AccountContractFactory.create(contract=contract)

    contract_reserves = [
        ContractReserveFactory.create(contract=contract) for contract in contracts
    ]
    contract_reserve_ids = [cr.contract_reserve_id for cr in contract_reserves]

    result = ContractReserve.get_by_ids(contract_reserve_ids)

    assert len(result) == 2
    assert all(res.contract_reserve_id in contract_reserve_ids for res in result)
    assert all(res.account_id for res in result)


def test_get_by_contract_ids():
    """Test to get reserves by contract_ids."""
    contracts = ContractFactory.create_batch(3)
    contract_ids = [contract.contract_id for contract in contracts]
    ContractReserveFactory.create(contract=contracts[0])
    ContractReserveFactory.create(contract=contracts[2])

    result = ContractReserve.get_by_contract_ids(contract_ids)

    assert len(result) == 2
    assert any(res.contract_id in contract_ids for res in result)


def test_get_by_contract_ids_excludes_deleted_reserves():
    """Test getting reserves by contract_ids only returns active reserves."""
    contract = ContractFactory.create()

    deleted_reserve = ContractReserveFactory.create(contract=contract)
    deleted_reserve.deleted_at = '2023-01-01'
    deleted_reserve.deleted_by = 'your mama'

    active_reserve = ContractReserveFactory.create(contract=contract)

    result = ContractReserve.get_by_contract_ids([contract.contract_id])

    assert len(result) == 1
    assert active_reserve in result
    assert deleted_reserve not in result
    assert active_reserve.contract == contract
    assert deleted_reserve.contract == contract


def test_contract_reserve_soft_delete():
    """Test contract_reserve soft delete fields."""
    contract = ContractFactory.create()
    reserve = ContractReserve.create(
        contract_id=contract.contract_id,
        reserve_rate=50,
        reserve_release_offset_in_months=1,
        installments_in_months=2,
        release_schedule=[25, 25]
    )
    result = ContractReserve.query.all()
    assert len(result) == 1
    assert result[0] == reserve

    reserve.update_attributes(
        deleted_by='test',
        deleted_at='2022-01-17',
    )
    reserve.commit_changes()

    # Show deleted_at can be filtered over
    result = ContractReserve.query.filter(ContractReserve.deleted_at is None).all()
    assert len(result) == 0

    result = ContractReserve.query.filter(ContractReserve.deleted_at is not None).all()
    assert len(result) == 1
    assert result[0] == reserve