"""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
from abacus_contract.models import 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


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_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
    )