"""Business logic for Payment Search."""

import datetime

from payment.connectors.cortex_search import and_, eq_, get_client, gte_, lte_, or_
from payment.constants.constants import (
    PAYMENT_SEARCH_COLUMNS,
    PAYMENT_SEARCH_LIMIT,
    PAYMENT_SEARCH_QUERY,
)
from payment.constants.error import ERROR_PAYMENTS_SEARCH_REQUIRED_FILTERS
from payment.logic.exceptions import LogicError
from payment.models.generic import Items


def search_payments(
    account: str | None = None,
    contract: str | None = None,
    payment_types: list[str] | None = None,
    payment_statuses: list[str] | None = None,
    payment_release_date_from: datetime.date | None = None,
    payment_release_date_to: datetime.date | None = None,
    payment_created_date_from: datetime.date | None = None,
    payment_created_date_to: datetime.date | None = None,
) -> Items:
    """Search payments via Cortex Search using the provided filters.

    At least one filter must be provided; raises LogicError otherwise.
    Returns a generic Items model.
    """
    if not any(
        [
            account,
            contract,
            payment_types,
            payment_statuses,
            payment_release_date_from,
            payment_release_date_to,
            payment_created_date_from,
            payment_created_date_to,
        ]
    ):
        raise LogicError(ERROR_PAYMENTS_SEARCH_REQUIRED_FILTERS)

    conditions = []
    if account:
        conditions.append(
            or_(
                eq_(PAYMENT_SEARCH_COLUMNS.ACCOUNT_ID, account),
                eq_(PAYMENT_SEARCH_COLUMNS.ACCOUNT_NAME, account),
            )
        )
    if contract:
        conditions.append(
            or_(
                eq_(PAYMENT_SEARCH_COLUMNS.CONTRACT_ID, contract),
                eq_(PAYMENT_SEARCH_COLUMNS.CONTRACT_NAME, contract),
            )
        )
    if payment_types:
        conditions.append(
            or_(*[eq_(PAYMENT_SEARCH_COLUMNS.PAYMENT_TYPE, t) for t in payment_types])
        )
    if payment_statuses:
        conditions.append(
            or_(
                *[
                    eq_(PAYMENT_SEARCH_COLUMNS.PAYMENT_STATUS, s)
                    for s in payment_statuses
                ]
            )
        )
    if payment_release_date_from:
        conditions.append(
            gte_(PAYMENT_SEARCH_COLUMNS.PAYMENT_RELEASE_DATE, payment_release_date_from)
        )
    if payment_release_date_to:
        conditions.append(
            lte_(PAYMENT_SEARCH_COLUMNS.PAYMENT_RELEASE_DATE, payment_release_date_to)
        )
    if payment_created_date_from:
        conditions.append(
            gte_(PAYMENT_SEARCH_COLUMNS.PAYMENT_CREATED_DATE, payment_created_date_from)
        )
    if payment_created_date_to:
        conditions.append(
            lte_(PAYMENT_SEARCH_COLUMNS.PAYMENT_CREATED_DATE, payment_created_date_to)
        )

    query_filter = and_(*conditions) if len(conditions) > 1 else conditions[0]

    items = get_client().search(
        query=PAYMENT_SEARCH_QUERY,
        columns=list(PAYMENT_SEARCH_COLUMNS),
        query_filter=query_filter,
        limit=PAYMENT_SEARCH_LIMIT,
    )

    return Items(items, len(items))