"""Payment Group Payment model unit tests."""

from abacus_common_logic.connectors.database import db
from sqlalchemy import select

from payment.models import PaymentGroupPayment
from tests.utils.factories import (
    PaymentGroupFactory,
    PaymentGroupPaymentAccountFactory,
    PaymentGroupPaymentFactory,
)


def test_base_list_query():
    """Test base list query returns payment_group_payments."""
    payments = PaymentGroupPaymentFactory.create_batch(5)
    res = db.session.execute(PaymentGroupPayment.base_list_query()).mappings().all()

    assert len(res) == len(payments)
    assert all(payment_group_payment.created_at for payment_group_payment in res)
    assert all(payment_group_payment.payment_group_id for payment_group_payment in res)
    assert all(
        payment_group_payment.payment_group_payment_id for payment_group_payment in res
    )
    assert all(payment_group_payment.payment_name for payment_group_payment in res)
    assert all(
        payment_group_payment.account_count == 0 for payment_group_payment in res
    )


def test_base_list_query_includes_account_count(mock_accounts):
    """Test base list query includes correct account_count."""
    payment_group_payment = PaymentGroupPaymentFactory.create()

    payment_accounts = [
        PaymentGroupPaymentAccountFactory.create(
            account_id=i, payment_group_payment=payment_group_payment
        )
        for i in range(1, 5)
    ]

    res = db.session.execute(PaymentGroupPayment.base_list_query()).mappings().all()

    assert len(res) == 1, 'Expected one result from base_list_query, got none.'
    assert res[0].account_count == len(
        payment_accounts
    ), f'Expected {len(payment_accounts)} accounts, but got {res[0].account_count}'


def test_base_list_query_includes_account_count_exlcudes_delete_pending(mock_accounts):
    """Test base list query includes correct account_count."""
    prior_payment_group_payment = PaymentGroupPaymentFactory.create()

    payment_group_payment = PaymentGroupPaymentFactory.create()

    PaymentGroupPaymentAccountFactory.create(
        account_id=1, payment_group_payment=payment_group_payment
    )  # active
    PaymentGroupPaymentAccountFactory.create(
        account_id=2,
        payment_group_payment=payment_group_payment,
        deleted_at='2021-12-01',
        deleted_by='user',
    )  # deleted
    PaymentGroupPaymentAccountFactory.create(
        account_id=3,
        payment_group_payment=payment_group_payment,
        deleted_at='2021-12-01',
        deleted_by='user',
        prior_payment_group_payment_id=prior_payment_group_payment.payment_group_payment_id,
    )  # pending
    res = db.session.execute(PaymentGroupPayment.base_list_query()).mappings().all()

    assert len(res) == 2, f'Expected 2 results from base_list_query, got {len(res)}.'
    assert (
        res[1].account_count == 1
    ), f'Expected 1 accounts, but got {res[0].account_count}'


def test_base_list_query_excludes_deletions():
    """Test base list query returns results that have not been deleted."""
    payments = PaymentGroupPaymentFactory.create_batch(5)
    deleted_payment = PaymentGroupPaymentFactory.create(
        deleted_at='2021-12-01', deleted_by='user'
    )
    res = db.session.execute(PaymentGroupPayment.base_list_query()).mappings().all()

    assert len(res) == len(payments)
    assert deleted_payment.payment_group_payment_id not in [
        payment_group_payment.payment_group_payment_id for payment_group_payment in res
    ]


def test_create():
    """Create a payment_group."""
    payment_group = PaymentGroupFactory.create()

    PaymentGroupPayment.create(
        payment_group_id=payment_group.payment_group_id,
        statement_period_id=2,
        payment_name='July 2020',
    )

    payment_group_payments = (
        db.session.execute(select(PaymentGroupPayment)).scalars().all()
    )
    payment_group_payment = payment_group_payments[0]

    assert len(payment_group_payments) == 1
    assert payment_group.payment_group_payments == payment_group_payments
    assert payment_group_payment.payment_group == payment_group
    assert payment_group_payment.payment_name == 'July 2020'
    assert payment_group_payment.statement_period_id == 2
    assert not payment_group_payment.deleted_at
    assert not payment_group_payment.deleted_by


def test_is_sent(create_mock_payment_state):
    """Test if payment_group_payment's send action is complete or running."""
    posted_payment_group_payment = PaymentGroupPaymentFactory.create()
    un_posted_payment_group_payment = PaymentGroupPaymentFactory.create()

    assert posted_payment_group_payment.is_sent()
    assert not un_posted_payment_group_payment.is_sent()