"""Logic for reference_transaction_type_group."""

from abacus_common_logic.constants.error import ERROR_ENTITY_DOES_NOT_EXIST
from owsresponse import response

from abacus_contract.constants.constants import REFERENCE_TRANSACTION_TYPE_GROUP_ADMIN
from abacus_contract.constants.error import ERROR_INVALID_GROUP_ADMIN
from abacus_contract.models import (
    ReferenceTransactionTypeGroup,
    ReferenceTransactionTypeGroupTransactionType,
)
from abacus_contract.schemas.reference_transaction_type import (
    ReferenceTransactionTypeSchema,
)
from abacus_contract.schemas.reference_transaction_type_group import (
    ReferenceTransactionTypeGroupSchema,
)
from abacus_contract.schemas.reference_transaction_type_group_transaction_type import (
    ReferenceTransactionTypeGroupTransactionTypeSchema,
)
from abacus_contract.utils.format_response import prepare_dataload_grouped_response


def get_groups_by_group_admin(group_admin: str) -> response.Response:
    """Get list of reference_transaction_type_groups by group_admin.

    Args:
        group_admin (str): one of REFERENCE_TRANSACTION_TYPE_GROUP_ADMIN
    """
    if group_admin.lower() not in REFERENCE_TRANSACTION_TYPE_GROUP_ADMIN:
        error_message = ERROR_INVALID_GROUP_ADMIN.format(
            group_admin=group_admin,
            group_admins=', '.join(REFERENCE_TRANSACTION_TYPE_GROUP_ADMIN),
        )
        return response.create_error_response(
            code='error', status=404, message=error_message
        )

    groups = ReferenceTransactionTypeGroupTransactionType.get_by_group_admin(
        group_admin.lower()
    )

    distinct_groups = list(
        set(item.reference_transaction_type_group for item in groups)
    )

    distinct_groups.sort(key=lambda grp: grp.transaction_type_group_name)

    return response.Response(
        message=ReferenceTransactionTypeGroupSchema(many=True).dump(distinct_groups),
        status=200,
    )


def get_transaction_types_by_group(
    reference_transaction_type_group_id: int,
) -> response.Response:
    """Get list of transaction types by parent reference_transaction_type_group.

    Args:
        reference_transaction_type_group_id (int): ID of the parent group
    """
    transaction_type_group = ReferenceTransactionTypeGroup.get_by_id(
        reference_transaction_type_group_id
    )

    if not transaction_type_group:
        error_message = ERROR_ENTITY_DOES_NOT_EXIST.format(
            object_type=ReferenceTransactionTypeGroup.get_class_name(),
            object_id=reference_transaction_type_group_id,
        )
        return response.create_error_response(
            code='error', status=404, message=error_message
        )

    transaction_types = list(
        set(
            item.reference_transaction_type
            for item in transaction_type_group.reference_transaction_type_group_transaction_type
        )
    )

    transaction_types.sort(key=lambda tt: tt.transaction_type_name)

    return response.Response(
        message=ReferenceTransactionTypeSchema(many=True).dump(transaction_types),
        status=200,
    )


def get_transaction_types_by_group_ids(
    group_ids: list[int],
) -> response.Response:
    """Batch reference transaction types for many parent groups.

    Returns one ordered entry per requested group id: the list of that group's
    transaction types (deduped and name-sorted, matching the single-group read),
    or None when the group has none.

    Args:
        group_ids (list[int]): reference_transaction_type_group ids.
    """
    unique_ids = list(dict.fromkeys(group_ids))
    junctions = ReferenceTransactionTypeGroupTransactionType.get_by_group_ids(
        unique_ids
    )

    message = prepare_dataload_grouped_response(
        unique_ids,
        junctions,
        group_key=lambda junction: junction.reference_transaction_type_group_id,
        child=lambda junction: junction.reference_transaction_type,
        serialize_group=lambda types: ReferenceTransactionTypeSchema(many=True).dump(
            types
        ),
        dedup_key=lambda tt: tt.reference_transaction_type_id,
        sort_key=lambda tt: tt.transaction_type_name,
    )

    return response.Response(message=message, status=200)


def get_transaction_type_group_transaction_types() -> response.Response:
    """Get list of transaction types and their transaction type group."""
    transaction_types_with_group = (
        ReferenceTransactionTypeGroupTransactionType.get_all()
    )

    return response.Response(
        message=ReferenceTransactionTypeGroupTransactionTypeSchema(many=True).dump(
            transaction_types_with_group
        ),
        status=200,
    )


def get_transaction_type_groups() -> response.Response:
    """Get list of all transaction type groups."""
    transaction_type_groups = ReferenceTransactionTypeGroup.get_all()

    return response.Response(
        message=ReferenceTransactionTypeGroupSchema(many=True).dump(
            transaction_type_groups
        ),
        status=200,
    )