"""Tests for WorksheetAccountContractPayableDetails model."""

from datetime import datetime
from decimal import Decimal

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

from payment.models import WorksheetAccountContractPayableDetails
from tests.utils.factories import (
    WorksheetAccountContractPayableDetailsFactory,
    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."""
    worksheet_payable = WorksheetPayableBalanceAfterTaxFactory.create()
    created_item = WorksheetAccountContractPayableDetails.create(
        # noqa
        worksheet_account_contract_payable_after_tax_id=worksheet_payable.worksheet_account_contract_payable_after_tax_id,
        contract_id=1,
        account_id=1,
        statement_period_id=1,
        target_table='test_table',
        target_id=1,
        reference_target_table='test_table_2',
        reference_target_id=1,
        payable_detail_type_id=1,
        amount_payable=Decimal('10.00'),
        currency='USD',
        notes='test note',
        created_at=datetime.now(),
        created_by='test',
        last_modified=datetime.now(),
        last_modified_by='test',
    )

    item_from_db = WorksheetAccountContractPayableDetails.get_by_id(
        created_item.worksheet_account_contract_payable_after_tax_id
    )

    assert item_from_db.worksheet_account_contract_payable_after_tax_id == 1
    assert item_from_db.contract_id == 1
    assert item_from_db.account_id == 1
    assert item_from_db.statement_period_id == 1
    assert item_from_db.target_table == 'test_table'
    assert item_from_db.target_id == 1
    assert item_from_db.reference_target_table == 'test_table_2'
    assert item_from_db.reference_target_id == 1
    assert item_from_db.payable_detail_type_id == 1
    assert item_from_db.amount_payable == Decimal('10.00')
    assert item_from_db.currency == 'USD'
    assert item_from_db.notes == 'test note'
    assert item_from_db.created_by == 'test'
    assert item_from_db.last_modified_by == 'test'
    assert item_from_db.deleted_at is None
    assert item_from_db.deleted_by is None
    assert (
        item_from_db.worksheet_account_contract_payable_after_tax == worksheet_payable
    )


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,
):
    """Test soft_delete_by_event_id method."""
    detail1 = WorksheetAccountContractPayableDetailsFactory.create(
        worksheet_account_contract_payable_after_tax__abacus_event_id=1
    )
    WorksheetAccountContractPayableDetailsFactory.create(
        worksheet_account_contract_payable_after_tax__abacus_event_id=2
    )

    WorksheetAccountContractPayableDetails.soft_delete_by_event_id(1)

    assert db.session.execute(
        select(WorksheetAccountContractPayableDetails).where(
            WorksheetAccountContractPayableDetails.deleted_at != None  # noqa
        )
    ).scalars().all() == [detail1]


def test_soft_delete_by_worksheet_payable_after_tax_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_worksheet_payable_after_tax_id sets deleted_at and deleted_by."""
    detail = WorksheetAccountContractPayableDetailsFactory.create()
    WorksheetAccountContractPayableDetails.soft_delete_by_worksheet_payable_after_tax_id(
        detail.worksheet_account_contract_payable_after_tax_id
    )
    deleted_detail = db.session.get(
        WorksheetAccountContractPayableDetails,
        detail.worksheet_account_contract_payable_details_id,
    )
    assert deleted_detail.deleted_at is not None
    assert deleted_detail.deleted_by is not None


def test_soft_delete_corrections_by_worksheet_payable_after_tax_ids(
    mock_statement_periods,
    mock_exchange_rates,
    mock_contracts,
    mock_accounts,
    mock_abacus_event,
    mock_ledger_account_contracts,
    mock_worksheet_account_contract_closing_balance,
):
    """Only vat/wht corrections (payable_detail_type_id in 4,5) are soft-deleted."""
    after_tax_payable = WorksheetPayableBalanceAfterTaxFactory.create()
    after_tax_id = after_tax_payable.worksheet_account_contract_payable_after_tax_id

    # Should be soft-deleted (wht and vat corrections).
    wht_correction = WorksheetAccountContractPayableDetailsFactory.create(
        worksheet_account_contract_payable_after_tax=after_tax_payable,
        payable_detail_type_id=4,
    )
    vat_correction = WorksheetAccountContractPayableDetailsFactory.create(
        worksheet_account_contract_payable_after_tax=after_tax_payable,
        payable_detail_type_id=5,
    )

    # Should NOT be soft-deleted (closing balance, payment allocation, other).
    closing_balance = WorksheetAccountContractPayableDetailsFactory.create(
        worksheet_account_contract_payable_after_tax=after_tax_payable,
        payable_detail_type_id=1,
    )
    payment_allocation = WorksheetAccountContractPayableDetailsFactory.create(
        worksheet_account_contract_payable_after_tax=after_tax_payable,
        payable_detail_type_id=6,
    )

    # Different after-tax id — should not be touched.
    other_after_tax = WorksheetPayableBalanceAfterTaxFactory.create()
    untouched = WorksheetAccountContractPayableDetailsFactory.create(
        worksheet_account_contract_payable_after_tax=other_after_tax,
        payable_detail_type_id=4,
    )

    WorksheetAccountContractPayableDetails.soft_delete_corrections_by_worksheet_payable_after_tax_ids(
        [after_tax_id]
    )
    db.session.expire_all()

    deleted_ids = {
        d.worksheet_account_contract_payable_details_id
        for d in db.session.execute(
            select(WorksheetAccountContractPayableDetails).where(
                WorksheetAccountContractPayableDetails.deleted_at.isnot(None)
            )
        )
        .scalars()
        .all()
    }

    assert deleted_ids == {
        wht_correction.worksheet_account_contract_payable_details_id,
        vat_correction.worksheet_account_contract_payable_details_id,
    }
    assert (
        closing_balance.worksheet_account_contract_payable_details_id not in deleted_ids
    )
    assert (
        payment_allocation.worksheet_account_contract_payable_details_id
        not in deleted_ids
    )
    assert untouched.worksheet_account_contract_payable_details_id not in deleted_ids