"""Contract Term Condition model tests."""

from datetime import datetime

from abacus_contract.models.contract_term_condition import ContractTermCondition
from abacus_contract.tests.utils.factories import (
    ContractTermConditionFactory,
    ContractTermFactory,
)


def test_get_active_term_conditions():
    """Test get active term conditions."""
    contract_term = ContractTermFactory.create()
    contract_term_conditions = ContractTermConditionFactory.create_batch(
        3, contract_term=contract_term
    )

    contract_term_conditions[0].deleted_at = datetime.today()
    contract_term_conditions[0].deleted_by = 'someone'

    active_conditions = ContractTermCondition.get_active_term_conditions(
        contract_term.contract_term_id
    ).all()

    assert len(active_conditions) == len(contract_term_conditions) - 1
    for active_condition in active_conditions:
        assert not active_condition.deleted_at
        assert not active_condition.deleted_by


def test_get_active_term_conditions_with_order_by():
    """Test get active term conditions are returned ordered by priority."""
    contract_term = ContractTermFactory.create()
    contract_term_conditions = [
        ContractTermConditionFactory.create(
            contract_term=contract_term, priority=priority
        )
        for priority in [3, 2, 1]
    ]

    active_conditions = ContractTermCondition.get_active_term_conditions_with_order_by(
        contract_term.contract_term_id
    )

    assert len(active_conditions) == len(contract_term_conditions)
    assert active_conditions[0].priority == 1
    assert active_conditions[1].priority == 2
    assert active_conditions[2].priority == 3
    assert active_conditions[0] == contract_term_conditions[2]
    assert active_conditions[1] == contract_term_conditions[1]
    assert active_conditions[2] == contract_term_conditions[0]


def test_get_active_term_conditions_by_term_ids():
    """Test batch-fetching active conditions for multiple contract_term_ids."""
    contract_term_1 = ContractTermFactory.create()
    contract_term_2 = ContractTermFactory.create()
    contract_term_1_conditions = [
        ContractTermConditionFactory.create(contract_term=contract_term_1, priority=p)
        for p in [2, 1]
    ]
    contract_term_2_condition = ContractTermConditionFactory.create(
        contract_term=contract_term_2, priority=1
    )

    deleted_condition = ContractTermConditionFactory.create(
        contract_term=contract_term_1, priority=3
    )
    deleted_condition.deleted_at = datetime.today()
    deleted_condition.deleted_by = 'someone'

    result = ContractTermCondition.get_active_term_conditions_by_term_ids(
        [contract_term_1.contract_term_id, contract_term_2.contract_term_id]
    )

    assert result == [
        contract_term_1_conditions[1],
        contract_term_1_conditions[0],
        contract_term_2_condition,
    ]


def test_active_term_conditions_equal_priority_tiebreak_by_pk():
    """Equal priorities order deterministically by primary key.

    The single and batch lookups agree so the batched resolver path never
    diverges.
    """
    contract_term = ContractTermFactory.create()
    first, second = [
        ContractTermConditionFactory.create(contract_term=contract_term, priority=1)
        for _ in range(2)
    ]
    assert first.contract_term_condition_id < second.contract_term_condition_id

    single = ContractTermCondition.get_active_term_conditions_with_order_by(
        contract_term.contract_term_id
    )
    batch = ContractTermCondition.get_active_term_conditions_by_term_ids(
        [contract_term.contract_term_id]
    )

    assert single == [first, second]
    assert batch == [first, second]


def test_get_active_term_conditions_by_term_ids_empty():
    """Test batch-fetching conditions with no matching contract_term_ids."""
    ContractTermConditionFactory.create()

    result = ContractTermCondition.get_active_term_conditions_by_term_ids([999999])

    assert result == []


def test_get_all_by_id():
    """Test getting all active contract_term_conditions by their IDs."""
    contract_term_conditions = ContractTermConditionFactory.create_batch(3)
    contract_term_condition_ids = [
        condition.contract_term_condition_id for condition in contract_term_conditions
    ]

    active_conditions = ContractTermCondition.get_all_by_id(contract_term_condition_ids)

    assert len(active_conditions) == len(contract_term_conditions)

    contract_term_conditions[0].deleted_at = datetime.today()
    contract_term_conditions[0].deleted_by = 'no one'

    active_conditions = ContractTermCondition.get_all_by_id(contract_term_condition_ids)

    assert len(active_conditions) == len(contract_term_conditions) - 1