"""Test cases for WorksheetPayableBalanceAfterTax model."""

from datetime import datetime
from decimal import Decimal
from unittest.mock import patch

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

from payment.models.worksheet_payable_balance_after_tax import (
    get_payments_matching_closing_balances,
    WorksheetPayableBalanceAfterTax,
)
from tests.utils.factories import (
    PaymentGroupPaymentAccountDetailFactory,
    PaymentGroupPaymentAccountFactory,
    PaymentGroupPaymentFactory,
    WorksheetAccountContractClosingBalanceFactory,
    WorksheetPayableBalanceAfterTaxFactory,
)


def test_create(
    mock_statement_periods,
    mock_exchange_rates,
    mock_contracts,
    mock_accounts,
    mock_abacus_event,
    mock_ledger_account_contracts,
    mock_worksheet_account_contract_closing_balance,
):
    """Test create WorksheetPayableBalanceAfterTax instance."""
    created_item = WorksheetPayableBalanceAfterTax.create(
        worksheet_account_contract_closing_balance_id=1,
        contract_id=1,
        account_id=1,
        statement_period_id=1,
        abacus_event_id=1,
        payable_amount_pre_tax=Decimal('100.00'),
        tax_withholding_amount=Decimal('10.00'),
        vat_amount=Decimal('-11.11'),
        payable_amount_post_tax=Decimal('110.00'),
        currency_code='USD',
        country_of_tax_residence='USA',
        country_of_tax_policy='USA',
        created_at=datetime.now(),
        created_by='test',
        last_modified=datetime.now(),
        last_modified_by='test',
    )

    worksheet_payable_balance_after_tax = WorksheetPayableBalanceAfterTax.get_by_id(
        created_item.worksheet_account_contract_payable_after_tax_id
    )

    worksheet_payable_balance_after_taxs = (
        db.session.execute(select(WorksheetPayableBalanceAfterTax)).scalars().all()
    )
    assert len(worksheet_payable_balance_after_taxs) == 1

    assert (
        worksheet_payable_balance_after_tax.worksheet_account_contract_payable_after_tax_id  # noqa
        == 1
    )
    assert (
        worksheet_payable_balance_after_tax.worksheet_account_contract_closing_balance_id  # noqa
        == 1
    )
    assert worksheet_payable_balance_after_tax.contract_id == 1
    assert worksheet_payable_balance_after_tax.account_id == 1
    assert worksheet_payable_balance_after_tax.statement_period_id == 1
    assert worksheet_payable_balance_after_tax.abacus_event_id == 1
    assert worksheet_payable_balance_after_tax.payable_amount_pre_tax == Decimal(
        '100.00'
    )
    assert worksheet_payable_balance_after_tax.tax_withholding_amount == Decimal(
        '10.00'
    )
    assert worksheet_payable_balance_after_tax.vat_amount == Decimal('-11.11')
    assert worksheet_payable_balance_after_tax.payable_amount_post_tax == Decimal(
        '110.00'
    )
    assert worksheet_payable_balance_after_tax.currency_code == 'USD'
    assert worksheet_payable_balance_after_tax.country_of_tax_residence == 'USA'
    assert worksheet_payable_balance_after_tax.country_of_tax_policy == 'USA'
    assert worksheet_payable_balance_after_tax.created_by == 'test'
    assert worksheet_payable_balance_after_tax.last_modified_by == 'test'
    assert worksheet_payable_balance_after_tax.deleted_at is None
    assert worksheet_payable_balance_after_tax.deleted_by is None


def test_filter_active(
    mock_statement_periods,
    mock_exchange_rates,
    mock_contracts,
    mock_accounts,
    mock_abacus_event,
    mock_ledger_account_contracts,
    mock_worksheet_account_contract_closing_balance,
):
    """Filter active worksheet instances."""
    contract_id = 1
    account_id = 1
    abacus_event_id = 1
    statement_period_id = 1
    worksheet_account_contract_closing_balance_id = 1
    payable_amount_pre_tax = Decimal('100.00')
    tax_withholding_amount = Decimal('10.00')
    payable_amount_post_tax = Decimal('110.00')
    currency_code = 'USD'
    country_of_tax_residence = 'USA'
    country_of_tax_policy = 'USA'
    created_at = datetime.now()
    created_by = 'test'
    last_modified = datetime.now()
    last_modified_by = 'test'

    WorksheetPayableBalanceAfterTax.create(
        worksheet_account_contract_closing_balance_id=worksheet_account_contract_closing_balance_id,  # noqa
        contract_id=contract_id,
        account_id=account_id,
        statement_period_id=statement_period_id,
        abacus_event_id=abacus_event_id,
        payable_amount_pre_tax=payable_amount_pre_tax,
        tax_withholding_amount=tax_withholding_amount,
        payable_amount_post_tax=payable_amount_post_tax,
        currency_code=currency_code,
        country_of_tax_residence=country_of_tax_residence,
        country_of_tax_policy=country_of_tax_policy,
        created_at=created_at,
        created_by=created_by,
        last_modified=last_modified,
        last_modified_by=last_modified_by,
        deleted_at=datetime.now(),
        deleted_by='test',
    )

    WorksheetPayableBalanceAfterTax.create(
        worksheet_account_contract_closing_balance_id=worksheet_account_contract_closing_balance_id,  # noqa
        contract_id=contract_id,
        account_id=account_id,
        statement_period_id=statement_period_id,
        abacus_event_id=abacus_event_id,
        payable_amount_pre_tax=payable_amount_pre_tax,
        tax_withholding_amount=tax_withholding_amount,
        payable_amount_post_tax=payable_amount_post_tax,
        currency_code=currency_code,
        country_of_tax_residence=country_of_tax_residence,
        country_of_tax_policy=country_of_tax_policy,
        created_at=created_at,
        created_by=created_by,
        last_modified=last_modified,
        last_modified_by=last_modified_by,
    )

    worksheet_payable_balance_after_taxs = (
        db.session.execute(WorksheetPayableBalanceAfterTax.filter_active())
        .scalars()
        .all()
    )
    assert len(worksheet_payable_balance_after_taxs) == 1


def test_filter_by_contracts_statement_period_event_id(
    mock_statement_periods,
    mock_exchange_rates,
    mock_contracts,
    mock_accounts,
    mock_abacus_event,
    mock_ledger_account_contracts,
    mock_worksheet_account_contract_closing_balance,
):
    """Filter by contracts and statement period."""
    contract_id = 1
    account_id = 1
    abacus_event_id = 1
    statement_period_id = 1
    worksheet_account_contract_closing_balance_id = 1
    payable_amount_pre_tax = Decimal('100.00')
    tax_withholding_amount = Decimal('10.00')
    payable_amount_post_tax = Decimal('110.00')
    currency_code = 'USD'
    country_of_tax_residence = 'USA'
    country_of_tax_policy = 'USA'
    created_at = datetime.now()
    created_by = 'test'
    last_modified = datetime.now()
    last_modified_by = 'test'

    WorksheetPayableBalanceAfterTax.create(
        worksheet_account_contract_closing_balance_id=worksheet_account_contract_closing_balance_id,  # noqa
        contract_id=contract_id,
        account_id=account_id,
        statement_period_id=statement_period_id,
        abacus_event_id=abacus_event_id,
        payable_amount_pre_tax=payable_amount_pre_tax,
        tax_withholding_amount=tax_withholding_amount,
        payable_amount_post_tax=payable_amount_post_tax,
        currency_code=currency_code,
        country_of_tax_residence=country_of_tax_residence,
        country_of_tax_policy=country_of_tax_policy,
        created_at=created_at,
        created_by=created_by,
        last_modified=last_modified,
        last_modified_by=last_modified_by,
    )

    WorksheetPayableBalanceAfterTax.create(
        worksheet_account_contract_closing_balance_id=worksheet_account_contract_closing_balance_id,  # noqa
        contract_id=contract_id,
        account_id=account_id,
        statement_period_id=statement_period_id,
        abacus_event_id=abacus_event_id + 1,
        payable_amount_pre_tax=payable_amount_pre_tax,
        tax_withholding_amount=tax_withholding_amount,
        payable_amount_post_tax=payable_amount_post_tax,
        currency_code=currency_code,
        country_of_tax_residence=country_of_tax_residence,
        country_of_tax_policy=country_of_tax_policy,
        created_at=created_at,
        created_by=created_by,
        last_modified=last_modified,
        last_modified_by=last_modified_by,
    )

    contract_ids = [1]
    statement_period_id = 1
    worksheet_payable_balance_after_taxs = (
        db.session.execute(
            WorksheetPayableBalanceAfterTax.filter_by_contracts_statement_period_event_id(
                contract_ids, statement_period_id, abacus_event_id
            )
        )
        .scalars()
        .all()
    )
    assert len(worksheet_payable_balance_after_taxs) == 1


def test_soft_delete_by_payment_group_payment(
    mock_accounts, mock_contracts, mock_abacus_event, mock_ledger_account_contracts
):
    """Test deleting by payment_group_payment."""
    payment_group_payment = PaymentGroupPaymentFactory.create(
        payment_group_payment_id=1
    )
    payment_group_payment_account = PaymentGroupPaymentAccountFactory.create(
        payment_group_payment=payment_group_payment
    )
    worksheet_closing_balance = WorksheetAccountContractClosingBalanceFactory.create()
    worksheet_after_tax1 = WorksheetPayableBalanceAfterTaxFactory.create(
        # noqa
        worksheet_account_contract_closing_balance_id=worksheet_closing_balance.worksheet_account_contract_closing_balance_id,
        abacus_event_id=1,
    )
    worksheet_after_tax2 = WorksheetPayableBalanceAfterTaxFactory.create(
        # noqa
        worksheet_account_contract_closing_balance_id=worksheet_closing_balance.worksheet_account_contract_closing_balance_id,
        abacus_event_id=2,
    )
    detail1 = PaymentGroupPaymentAccountDetailFactory.create(
        # noqa
        worksheet_account_contract_payable_after_tax_id=worksheet_after_tax1.worksheet_account_contract_payable_after_tax_id,
        payment_group_payment_account=payment_group_payment_account,
    )
    PaymentGroupPaymentAccountDetailFactory.create(
        # noqa
        worksheet_account_contract_payable_after_tax_id=worksheet_after_tax2.worksheet_account_contract_payable_after_tax_id
    )
    WorksheetPayableBalanceAfterTax.soft_delete_by_payment_group_payment(
        detail1.payment_group_payment_account.payment_group_payment_id
    )
    assert db.session.execute(
        select(WorksheetPayableBalanceAfterTax).where(
            WorksheetPayableBalanceAfterTax.deleted_at != None  # noqa
        )
    ).scalars().all() == [worksheet_after_tax1]


def test_soft_delete_by_payment_group_payment_account(
    mock_accounts, mock_contracts, mock_abacus_event, mock_ledger_account_contracts
):
    """Test deleting by payment_group_payment_account."""
    worksheet_closing_balance = WorksheetAccountContractClosingBalanceFactory.create()
    worksheet_after_tax1 = WorksheetPayableBalanceAfterTaxFactory.create(
        # noqa
        worksheet_account_contract_closing_balance_id=worksheet_closing_balance.worksheet_account_contract_closing_balance_id
    )
    worksheet_after_tax2 = WorksheetPayableBalanceAfterTaxFactory.create(
        # noqa
        worksheet_account_contract_closing_balance_id=worksheet_closing_balance.worksheet_account_contract_closing_balance_id
    )
    detail1 = PaymentGroupPaymentAccountDetailFactory.create(
        # noqa
        worksheet_account_contract_payable_after_tax_id=worksheet_after_tax1.worksheet_account_contract_payable_after_tax_id
    )
    PaymentGroupPaymentAccountDetailFactory.create(
        # noqa
        worksheet_account_contract_payable_after_tax_id=worksheet_after_tax2.worksheet_account_contract_payable_after_tax_id
    )
    WorksheetPayableBalanceAfterTax.soft_delete_by_payment_group_payment_account(
        detail1.payment_group_payment_account_id
    )
    assert db.session.execute(
        select(WorksheetPayableBalanceAfterTax).where(
            WorksheetPayableBalanceAfterTax.deleted_at != None  # noqa
        )
    ).scalars().all() == [worksheet_after_tax1]


def test_soft_delete_by_event_id(
    mock_statement_periods,
    mock_exchange_rates,
    mock_contracts,
    mock_accounts,
    mock_abacus_event,
    mock_ledger_account_contracts,
    mock_worksheet_account_contract_closing_balance,
):
    """Soft delete items by event_id."""
    worksheet1 = WorksheetPayableBalanceAfterTaxFactory.create(abacus_event_id=1)
    worksheet2 = WorksheetPayableBalanceAfterTaxFactory.create(abacus_event_id=1)
    WorksheetPayableBalanceAfterTaxFactory.create(abacus_event_id=2)
    PaymentGroupPaymentAccountDetailFactory.create(
        # noqa
        worksheet_account_contract_payable_after_tax_id=worksheet1.worksheet_account_contract_payable_after_tax_id
    )
    WorksheetPayableBalanceAfterTax.soft_delete_by_event_id(event_id=1)
    assert db.session.execute(
        select(WorksheetPayableBalanceAfterTax).where(
            WorksheetPayableBalanceAfterTax.deleted_at != None  # noqa
        )
    ).scalars().all() == [worksheet2]


def test_get_payments_matching_closing_balances(
    mock_statement_periods,
    mock_accounts,
    mock_contracts,
    mock_abacus_event,
    mock_ledger_account_contracts,
):
    """Test get matching payments returns matching payment."""
    statement_period_id = 1
    worksheet_closing_balance = WorksheetAccountContractClosingBalanceFactory.create(
        statement_period_id=statement_period_id
    )
    worksheet_after_tax = WorksheetPayableBalanceAfterTaxFactory.create(
        # noqa
        worksheet_account_contract_closing_balance_id=worksheet_closing_balance.worksheet_account_contract_closing_balance_id,
        statement_period_id=statement_period_id,
        abacus_event_id=1,
    )
    payment = PaymentGroupPaymentFactory.create()
    payment_account = PaymentGroupPaymentAccountFactory.create(
        payment_group_payment=payment,
        payment_group_payment_id=payment.payment_group_payment_id,
    )
    PaymentGroupPaymentAccountDetailFactory.create(
        payment_group_payment_account=payment_account,
        worksheet_account_contract_payable_after_tax_id=worksheet_after_tax.worksheet_account_contract_payable_after_tax_id,
    )
    new_worksheet_after_tax = WorksheetPayableBalanceAfterTaxFactory.create(
        # noqa
        worksheet_account_contract_closing_balance_id=worksheet_closing_balance.worksheet_account_contract_closing_balance_id,
        statement_period_id=statement_period_id,
    )
    matching = get_payments_matching_closing_balances(
        [new_worksheet_after_tax.worksheet_account_contract_payable_after_tax_id]
    )[0]
    assert matching.payment_group_payment_id == payment_account.payment_group_payment_id


def test_get_payments_matching_closing_balances_deleted(
    mock_statement_periods,
    mock_accounts,
    mock_contracts,
    mock_abacus_event,
    mock_worksheet_account_contract_closing_balance,
):
    """Test get matching payments returns none if payment deleted."""
    statement_period_id = 1
    worksheet_closing_balance = WorksheetAccountContractClosingBalanceFactory.create(
        statement_period_id=statement_period_id
    )
    worksheet_after_tax = WorksheetPayableBalanceAfterTaxFactory.create(
        # noqa
        worksheet_account_contract_closing_balance_id=worksheet_closing_balance.worksheet_account_contract_closing_balance_id,
        statement_period_id=statement_period_id,
        abacus_event_id=1,
        deleted_at=datetime.now(),
    )
    payment = PaymentGroupPaymentFactory.create()
    payment_account = PaymentGroupPaymentAccountFactory.create(
        payment_group_payment=payment,
        payment_group_payment_id=payment.payment_group_payment_id,
        deleted_at=datetime.now(),
    )
    PaymentGroupPaymentAccountDetailFactory.create(
        payment_group_payment_account=payment_account,
        worksheet_account_contract_payable_after_tax_id=worksheet_after_tax.worksheet_account_contract_payable_after_tax_id,
        deleted_at=datetime.now(),
    )
    new_worksheet_after_tax = WorksheetPayableBalanceAfterTaxFactory.create(
        # noqa
        worksheet_account_contract_closing_balance_id=worksheet_closing_balance.worksheet_account_contract_closing_balance_id,
        statement_period_id=statement_period_id,
    )
    matching = get_payments_matching_closing_balances(
        [new_worksheet_after_tax.worksheet_account_contract_payable_after_tax_id]
    )
    assert matching == []


def test_get_payments_matching_closing_balances_canceled(
    mock_statement_periods,
    mock_accounts,
    mock_contracts,
    mock_abacus_event,
    mock_worksheet_account_contract_closing_balance,
    create_mock_payment_state,
):
    """Test get matching payments returns none if payment canceled."""
    statement_period_id = 1
    worksheet_closing_balance = WorksheetAccountContractClosingBalanceFactory.create(
        statement_period_id=statement_period_id
    )
    worksheet_after_tax = WorksheetPayableBalanceAfterTaxFactory.create(
        # noqa
        worksheet_account_contract_closing_balance_id=worksheet_closing_balance.worksheet_account_contract_closing_balance_id,
        statement_period_id=statement_period_id,
        abacus_event_id=1,
    )
    payment = PaymentGroupPaymentFactory.create()
    payment_account = PaymentGroupPaymentAccountFactory.create(
        # rejected state fixture
        payment_group_payment_account_id=3,
        payment_group_payment=payment,
        payment_group_payment_id=payment.payment_group_payment_id,
    )
    PaymentGroupPaymentAccountDetailFactory.create(
        payment_group_payment_account=payment_account,
        worksheet_account_contract_payable_after_tax_id=worksheet_after_tax.worksheet_account_contract_payable_after_tax_id,
    )
    new_worksheet_after_tax = WorksheetPayableBalanceAfterTaxFactory.create(
        # noqa
        worksheet_account_contract_closing_balance_id=worksheet_closing_balance.worksheet_account_contract_closing_balance_id,
        statement_period_id=statement_period_id,
    )
    matching = get_payments_matching_closing_balances(
        [new_worksheet_after_tax.worksheet_account_contract_payable_after_tax_id]
    )
    assert matching == []


def test_get_payments_matching_closing_balances_same_payable(
    mock_statement_periods,
    mock_accounts,
    mock_contracts,
    mock_abacus_event,
    mock_worksheet_account_contract_closing_balance,
):
    """Test get matching payments returns none if payable ids match."""
    statement_period_id = 1
    worksheet_closing_balance = WorksheetAccountContractClosingBalanceFactory.create(
        statement_period_id=statement_period_id
    )
    worksheet_after_tax = WorksheetPayableBalanceAfterTaxFactory.create(
        # noqa
        worksheet_account_contract_closing_balance_id=worksheet_closing_balance.worksheet_account_contract_closing_balance_id,
        statement_period_id=statement_period_id,
        abacus_event_id=1,
    )
    payment = PaymentGroupPaymentFactory.create()
    payment_account = PaymentGroupPaymentAccountFactory.create(
        payment_group_payment=payment,
        payment_group_payment_id=payment.payment_group_payment_id,
    )
    PaymentGroupPaymentAccountDetailFactory.create(
        payment_group_payment_account=payment_account,
        worksheet_account_contract_payable_after_tax_id=worksheet_after_tax.worksheet_account_contract_payable_after_tax_id,
    )

    matching = get_payments_matching_closing_balances(
        [worksheet_after_tax.worksheet_account_contract_payable_after_tax_id]
    )
    assert matching == []


def test_get_payments_matching_closing_balances_no_payment(
    mock_statement_periods,
    mock_accounts,
    mock_contracts,
    mock_abacus_event,
    mock_worksheet_account_contract_closing_balance,
):
    """Test get matching payments returns none if there is no payment."""
    statement_period_id = 1
    worksheet_closing_balance = WorksheetAccountContractClosingBalanceFactory.create(
        statement_period_id=statement_period_id
    )
    worksheet_after_tax = WorksheetPayableBalanceAfterTaxFactory.create(
        # noqa
        worksheet_account_contract_closing_balance_id=worksheet_closing_balance.worksheet_account_contract_closing_balance_id,
        statement_period_id=statement_period_id,
        abacus_event_id=1,
    )
    matching = get_payments_matching_closing_balances(
        [worksheet_after_tax.worksheet_account_contract_payable_after_tax_id]
    )
    assert matching == []


def test_get_payments_matching_closing_balances_prior(
    mock_statement_periods,
    mock_accounts,
    mock_contracts,
    mock_abacus_event,
    mock_worksheet_account_contract_closing_balance,
):
    """Test get matching payments returns none if payment has prior id."""
    statement_period_id = 1
    worksheet_closing_balance = WorksheetAccountContractClosingBalanceFactory.create(
        statement_period_id=statement_period_id
    )
    worksheet_after_tax = WorksheetPayableBalanceAfterTaxFactory.create(
        # noqa
        worksheet_account_contract_closing_balance_id=worksheet_closing_balance.worksheet_account_contract_closing_balance_id,
        statement_period_id=statement_period_id,
        abacus_event_id=1,
        deleted_at=datetime.now(),
    )
    payment = PaymentGroupPaymentFactory.create()
    prior_payment = PaymentGroupPaymentFactory.create()
    payment_account = PaymentGroupPaymentAccountFactory.create(
        payment_group_payment=payment,
        payment_group_payment_id=payment.payment_group_payment_id,
        deleted_at=datetime.now(),
        prior_payment_group_payment_id=prior_payment.payment_group_payment_id,
    )
    PaymentGroupPaymentAccountDetailFactory.create(
        payment_group_payment_account=payment_account,
        worksheet_account_contract_payable_after_tax_id=worksheet_after_tax.worksheet_account_contract_payable_after_tax_id,
        deleted_at=datetime.now(),
    )
    new_worksheet_after_tax = WorksheetPayableBalanceAfterTaxFactory.create(
        # noqa
        worksheet_account_contract_closing_balance_id=worksheet_closing_balance.worksheet_account_contract_closing_balance_id,
        statement_period_id=statement_period_id,
    )
    matching = get_payments_matching_closing_balances(
        [new_worksheet_after_tax.worksheet_account_contract_payable_after_tax_id]
    )
    assert matching == []


def test_get_by_payment_group_payment_and_account_ids(
    mock_statement_periods,
    mock_accounts,
    mock_contracts,
    mock_abacus_event,
    mock_worksheet_account_contract_closing_balance,
):
    """Test get associated worksheets"""
    mock_payment_group_payment_id = 1
    mock_account = 1
    worksheet_after_tax = WorksheetPayableBalanceAfterTaxFactory.create(
        abacus_event_id=1, payable_amount_post_tax=Decimal('20.00')
    )
    worksheet_after_tax_unrecouped = WorksheetPayableBalanceAfterTaxFactory.create(
        abacus_event_id=1, contract_id=2, payable_amount_post_tax=Decimal(0.0)
    )
    response = (
        WorksheetPayableBalanceAfterTax.get_by_payment_group_payment_and_account_ids(
            mock_payment_group_payment_id, [1, 2]
        )
    )
    assert response == {
        mock_account: [worksheet_after_tax, worksheet_after_tax_unrecouped]
    }

    # filter payable
    response = (
        WorksheetPayableBalanceAfterTax.get_by_payment_group_payment_and_account_ids(
            mock_payment_group_payment_id, [1, 2], True
        )
    )
    assert response == {mock_account: [worksheet_after_tax]}


def test_get_overview_by_event_id(
    mock_statement_periods,
    mock_accounts,
    mock_contracts,
    mock_abacus_event,
    mock_ledger_account_contracts,
    mock_worksheet_account_contract_closing_balance,
):
    from decimal import Decimal

    event_id = 1
    WorksheetPayableBalanceAfterTaxFactory.create(
        abacus_event_id=event_id,
        payable_amount_pre_tax=Decimal('100.00'),
        tax_withholding_amount=Decimal('10.00'),
        vat_amount=Decimal('5.00'),
        payable_amount_post_tax=Decimal('85.00'),
        account_id=1,
        contract_id=1,
    )
    WorksheetPayableBalanceAfterTaxFactory.create(
        abacus_event_id=event_id,
        payable_amount_pre_tax=Decimal('200.00'),
        tax_withholding_amount=Decimal('20.00'),
        vat_amount=Decimal('10.00'),
        payable_amount_post_tax=Decimal('170.00'),
        account_id=1,
        contract_id=1,
    )

    overview = WorksheetPayableBalanceAfterTax.get_overview_by_event_id(event_id)
    assert overview.payable_amount_pre_tax == Decimal('300.00')
    assert overview.tax_withholding_amount == Decimal('30.00')
    assert overview.vat_amount == Decimal('15.00')
    assert overview.payable_amount_post_tax == Decimal('255.00')


def test_soft_delete_by_id(
    mock_statement_periods,
    mock_exchange_rates,
    mock_contracts,
    mock_accounts,
    mock_abacus_event,
    mock_ledger_account_contracts,
    mock_worksheet_account_contract_closing_balance,
):
    """Test soft_delete_by_id sets deleted_at and deleted_by."""
    worksheet = WorksheetPayableBalanceAfterTaxFactory.create()

    WorksheetPayableBalanceAfterTax.soft_delete_by_id(
        worksheet.worksheet_account_contract_payable_after_tax_id
    )

    deleted_worksheet = db.session.get(
        WorksheetPayableBalanceAfterTax,
        worksheet.worksheet_account_contract_payable_after_tax_id,
    )
    assert deleted_worksheet.deleted_at is not None
    assert deleted_worksheet.deleted_by is not None


@patch('payment.models.worksheet_payable_balance_after_tax.get_flask_user_id')
def test_bulk_update(
    mock_get_flask_user_id,
    mock_statement_periods,
    mock_exchange_rates,
    mock_contracts,
    mock_accounts,
    mock_abacus_event,
    mock_ledger_account_contracts,
    mock_worksheet_account_contract_closing_balance,
):
    """Test bulk_update updates multiple worksheets."""
    user_id = '123'
    mock_get_flask_user_id.return_value = user_id

    worksheet_1 = WorksheetPayableBalanceAfterTaxFactory.create(
        tax_withholding_amount=10.00,
        vat_amount=5.00,
        payable_amount_post_tax=85.00,
    )
    worksheet_2 = WorksheetPayableBalanceAfterTaxFactory.create(
        tax_withholding_amount=20.00,
        vat_amount=10.00,
        payable_amount_post_tax=170.00,
    )

    updates = [
        {
            'worksheet_account_contract_payable_after_tax_id': worksheet_1.worksheet_account_contract_payable_after_tax_id,
            'tax_withholding_amount': 15.00,
            'vat_amount': 7.50,
            'payable_amount_post_tax': 77.50,
        },
        {
            'worksheet_account_contract_payable_after_tax_id': worksheet_2.worksheet_account_contract_payable_after_tax_id,
            'tax_withholding_amount': 25.00,
            'vat_amount': 12.50,
            'payable_amount_post_tax': 162.50,
        },
    ]

    WorksheetPayableBalanceAfterTax.bulk_update(updates)

    # Verify updates
    updated_worksheet_1 = WorksheetPayableBalanceAfterTax.get_by_id(
        worksheet_1.worksheet_account_contract_payable_after_tax_id
    )
    assert float(updated_worksheet_1.tax_withholding_amount) == 15.00
    assert float(updated_worksheet_1.vat_amount) == 7.50
    assert float(updated_worksheet_1.payable_amount_post_tax) == 77.50
    assert updated_worksheet_1.last_modified_by == user_id

    updated_worksheet_2 = WorksheetPayableBalanceAfterTax.get_by_id(
        worksheet_2.worksheet_account_contract_payable_after_tax_id
    )
    assert float(updated_worksheet_2.tax_withholding_amount) == 25.00
    assert float(updated_worksheet_2.vat_amount) == 12.50
    assert float(updated_worksheet_2.payable_amount_post_tax) == 162.50
    assert updated_worksheet_2.last_modified_by == user_id