"""Logic for the ReferenceSigningEntity admin endpoints."""

from marshmallow import ValidationError
from owsresponse import response

from abacus_contract import models
from abacus_contract.schemas.reference_signing_entity import (
    ReferenceSigningEntityFilterSchema,
    ReferenceSigningEntitySchema,
)
from abacus_contract.schemas.signing_entity_sap_profit_center import (
    SigningEntitySapProfitCenterDataloaderSchema,
    SigningEntitySapProfitCenterWithSapProfitCenterSchema,
)
from abacus_contract.utils.format_error import validation_error
from abacus_contract.utils.format_response import (
    prepare_dataload_response,
    prepare_dataload_with_data_as_list_response,
)
from abacus_contract.utils.request import validate_pagination_params


def list_sap_profit_centers_for_signing_entity(
    reference_signing_entity_id: int,
    search_term: str | None = None,
    limit: int | None = None,
    offset: int | None = None,
) -> response.Response:
    """List SAP profit centers a signing entity is authorized for (live mappings only).

    Powers the cascading dropdown on contract creation: user picks SE, then
    picks PC from the filtered list returned here.

    Returns 404 if the SE is missing or soft-deleted, matching the existing
    ``GET /reference-signing-entity/:id`` endpoint's treatment of soft-deleted
    SEs (see ``blueprints/reference_signing_entity.py``).
    """
    signing_entity = models.ReferenceSigningEntity.get_by_id_or_error(
        reference_signing_entity_id, error_status=404
    )
    if signing_entity.deleted_at is not None:
        return response.Response(
            message=(
                f'ReferenceSigningEntity {reference_signing_entity_id} does not exist.'
            ),
            status=404,
        )
    try:
        pagination = validate_pagination_params(
            limit if limit is not None else 50,
            offset if offset is not None else 0,
        )
    except Exception as exc:
        return validation_error(str(exc))

    items, total_count = (
        models.ReferenceSapProfitCenter.get_authorized_for_signing_entities(
            [reference_signing_entity_id],
            limit=pagination['limit'],
            offset=pagination['offset'],
            search_term=search_term,
        )
    )

    return response.Response(
        message={
            'items': SigningEntitySapProfitCenterWithSapProfitCenterSchema(
                many=True
            ).dump(items),
            'total_count': total_count,
        },
        status=200,
    )


def get_profit_centers_by_signing_entities(
    signing_entity_ids: list[int],
) -> response.Response:
    """Retrieve and structures active SAP profit centers authorized for specific signing entities.

    Args:
        signing_entity_ids (list[int]): A list of signing entity IDs to filter by.

    Returns:
        response.Response: A  response object containing fields from the SigningEntitySapProfitCenter
                alongside authorized SAP profit center mapping details.
    """
    unique_ids = list(dict.fromkeys(signing_entity_ids))
    items, _ = models.ReferenceSapProfitCenter.get_authorized_for_signing_entities(
        unique_ids, 100, 0
    )
    sap_profit_centers = SigningEntitySapProfitCenterWithSapProfitCenterSchema(
        many=True
    ).dump(items)

    message = prepare_dataload_with_data_as_list_response(
        unique_ids,
        sap_profit_centers,
        'reference_signing_entity_id',
    )

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


def get_signing_entities_by_ids(
    signing_entity_ids: list[int],
) -> response.Response:
    """Retrieve and structures signing entities.

    Args:
        signing_entity_ids (list[int]): A list of signing entity IDs

    Returns:
        response.Response: A  response object containing fields for signing entities.
    """
    unique_ids = list(dict.fromkeys(signing_entity_ids))
    items = models.ReferenceSigningEntity.get_by_ids(unique_ids)
    signing_entities = ReferenceSigningEntitySchema(many=True).dump(items)

    message = prepare_dataload_response(
        unique_ids,
        signing_entities,
        'reference_signing_entity_id',
    )

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


def get_reference_signing_entities(request_params: dict) -> response.Response:
    """Get the list of reference-signing-entities.

    Args:
        request_params (dict, optional): Query string parameters for pagination, sorting, and filtering.
            - limit (int): The maximum number of records to return per page.
            - offset (int): The number of records to skip before starting to return results.
            - sort_by (str): The column name used to sort the results.
            - sort_order (str): The sort direction, either "asc" or "desc".

    Returns:
        a list of reference-signing-entities.
    """
    try:
        params = ReferenceSigningEntityFilterSchema().load(request_params)
        items, total_count = (
            models.ReferenceSigningEntity.get_reference_signing_entities(**params)
        )

        message = dict(
            items=ReferenceSigningEntitySchema().dump(items, many=True),
            total_count=total_count,
        )
    except ValidationError as exc:
        return validation_error(str(exc))
    except Exception as e:
        raise e

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