"""Abacus Entry model tests."""

from abacus_common_logic.connectors.database import db
from abacus_common_logic.utils.dates import current_timestamp
from sqlalchemy import select

from abacus_event.models.abacus_event import AbacusEvent

from tests.utils.factories import AbacusEventFactory


def test_create(test_app):
    """Create a Abacus Event."""
    event_date = current_timestamp()
    AbacusEvent.create(
        event_name='accounting run commit',
        target_type='test_accounting_run',
        target_id=1,
        event_date=event_date,
    )
    stmt = select(AbacusEvent)
    abacus_events = db.session.execute(stmt).scalars().all()

    assert len(abacus_events) == 1
    assert abacus_events[0].target_type == 'test_accounting_run'
    assert abacus_events[0].event_name == 'accounting run commit'
    assert abacus_events[0].event_date == event_date.replace(tzinfo=None)
    assert abacus_events[0].created_by == 'default_user_id'


def test_get_payment_approval_count(test_app):
    """Test endpoint to get a approval count for a payment group."""
    payment_group_payment_id_1 = 10
    payment_group_payment_id_2 = 11

    AbacusEventFactory.create(
        event_name='payment_approval',
        target_id=payment_group_payment_id_1,
        target_type='payment_group_payment',
    )

    AbacusEventFactory.create(
        event_name='payment_approval',
        target_id=payment_group_payment_id_2,
        target_type='payment_group_payment',
    )

    AbacusEventFactory.create(
        event_name='payment_approval',
        target_id=payment_group_payment_id_1,
        target_type='payment_group_payment',
        rolled_back_at=current_timestamp(),
    )

    res_1 = AbacusEvent.get_payment_approval_count(payment_group_payment_id_1)
    res_2 = AbacusEvent.get_payment_approval_count(payment_group_payment_id_2)

    assert res_1.payment_group_payment_id == payment_group_payment_id_1
    assert res_1.approval_count == 1

    assert res_2.payment_group_payment_id == payment_group_payment_id_2
    assert res_2.approval_count == 1


def test_update_rollback_time(test_app):
    """Test to update rolled_back_at field for specified events."""
    event_name = 'payment_approval'
    target_id = 1
    target_type = 'payment_group_payment'

    abacus_event = AbacusEventFactory.create(
        event_name=event_name, target_id=target_id, target_type=target_type
    )

    assert abacus_event.rolled_back_at is None
    results = AbacusEvent.update_rollback_time(target_type, target_id, event_name)
    assert len(results) == 1
    assert results[0].rolled_back_at is not None


def test_get_events_by_target_type(test_app):
    """Test to get events for specified target type and id."""
    AbacusEventFactory.create(
        event_name='send_payments',
        target_id=1,
        target_type='payment_group_payment',
        statement_period_id=282,
    )

    AbacusEventFactory.create(
        event_name='payments_generate',
        target_id=1,
        target_type='payment_group_payment',
        statement_period_id=282,
    )

    AbacusEventFactory.create(
        event_name='send_payments',
        target_id=2,
        target_type='payment_group_payment',
        statement_period_id=282,
    )

    AbacusEventFactory.create(
        event_name='commit',
        target_id=1,
        target_type='payment_group',
        statement_period_id=282,
    )

    results = AbacusEvent.get_events_by_target_type('payment_group_payment', 1)
    assert len(results) == 2


def test_get_events_by_target_type_with_event_name(test_app):
    """Test get_events_by_target_type with event_name filter."""
    AbacusEventFactory.create(
        event_name='send_payments',
        target_id=1,
        target_type='payment_group_payment',
        statement_period_id=282,
    )
    AbacusEventFactory.create(
        event_name='payments_generate',
        target_id=1,
        target_type='payment_group_payment',
        statement_period_id=282,
    )
    AbacusEventFactory.create(
        event_name='send_payments',
        target_id=2,
        target_type='payment_group_payment',
        statement_period_id=282,
    )

    results = AbacusEvent.get_events_by_target_type(
        'payment_group_payment', 1, event_name='send_payments'
    )
    assert len(results) == 1
    assert results[0].event_name == 'send_payments'
    assert results[0].target_id == 1
    assert results[0].target_type == 'payment_group_payment'


def test_get_events_by_target_ids(test_app):
    """Test to get events for a target type across multiple target ids."""
    AbacusEventFactory.create(
        event_name='send_payments',
        target_id=1,
        target_type='payment_group_payment',
        statement_period_id=282,
    )
    AbacusEventFactory.create(
        event_name='payments_generate',
        target_id=2,
        target_type='payment_group_payment',
        statement_period_id=282,
    )
    AbacusEventFactory.create(
        event_name='send_payments',
        target_id=3,
        target_type='payment_group_payment',
        statement_period_id=282,
    )
    AbacusEventFactory.create(
        event_name='commit',
        target_id=1,
        target_type='payment_group',
        statement_period_id=282,
    )

    results = AbacusEvent.get_events_by_target_ids('payment_group_payment', [1, 2])
    assert len(results) == 2
    assert {result.target_id for result in results} == {1, 2}


def test_get_events_by_target_ids_excludes_rolled_back(test_app):
    """Test get_events_by_target_ids excludes rolled-back events."""
    AbacusEventFactory.create(
        event_name='send_payments',
        target_id=1,
        target_type='payment_group_payment',
        rolled_back_at=current_timestamp(),
    )
    AbacusEventFactory.create(
        event_name='send_payments',
        target_id=2,
        target_type='payment_group_payment',
    )

    results = AbacusEvent.get_events_by_target_ids('payment_group_payment', [1, 2])
    assert len(results) == 1
    assert results[0].target_id == 2


def test_get_events_by_target_ids_with_event_name(test_app):
    """Test get_events_by_target_ids with event_name filter."""
    AbacusEventFactory.create(
        event_name='send_payments',
        target_id=1,
        target_type='payment_group_payment',
    )
    AbacusEventFactory.create(
        event_name='payments_generate',
        target_id=2,
        target_type='payment_group_payment',
    )

    results = AbacusEvent.get_events_by_target_ids(
        'payment_group_payment', [1, 2], event_name='send_payments'
    )
    assert len(results) == 1
    assert results[0].target_id == 1


def test_get_events_by_target_type_returns_active_events_for_one_target(test_app):
    """get_events_by_target_type (delegates to the batch) returns one target's active events."""
    AbacusEventFactory.create(
        event_name='send_payments', target_id=1, target_type='payment_group_payment'
    )
    # Rolled-back event on the same target must be excluded via active_events().
    AbacusEventFactory.create(
        event_name='payments_generate',
        target_id=1,
        target_type='payment_group_payment',
        rolled_back_at=current_timestamp(),
    )
    # Different target id must not be returned.
    AbacusEventFactory.create(
        event_name='send_payments', target_id=2, target_type='payment_group_payment'
    )

    results = AbacusEvent.get_events_by_target_type('payment_group_payment', 1)

    assert len(results) == 1
    assert results[0].target_id == 1
    assert results[0].event_name == 'send_payments'


def test_get_by_id(test_app):
    """Test get_by_id method."""
    test_event1 = AbacusEventFactory.create(event_name='send_payments')

    test_event2 = AbacusEventFactory.create(
        event_name='payments_generate', rolled_back_at=current_timestamp()
    )

    assert AbacusEvent.get_by_id(test_event1.abacus_event_id) == test_event1
    assert AbacusEvent.get_by_id(test_event2.abacus_event_id) is None


def test_get_filtered_query(test_app):
    """Test get_filtered_query method."""
    test_event1 = AbacusEventFactory.create(event_name='send_payments')

    AbacusEventFactory.create(
        event_name='payments_generate', rolled_back_at=current_timestamp()
    )

    stmt = AbacusEvent.get_filtered_query(event_ids=[test_event1.abacus_event_id])
    result = db.session.execute(stmt).scalars().all()
    assert result == [test_event1]