"""Blueprint for SigningEntitySapProfitCenter (SE-PC junction) admin API."""

from abacus_common_logic.views.create_view import CreateView
from abacus_common_logic.views.item_view import ItemView
from abacus_common_logic.views.validations import validated_request_body
from common_apispec import doc, marshal_with, use_kwargs
from flask import Blueprint, request
from owsrequest import flask_request
from owsresponse import response
from owsresponse.adaptors.flask import flaskify

from abacus_contract import models
from abacus_contract.constants import error
from abacus_contract.logic import signing_entity_sap_profit_center as logic
from abacus_contract.schemas.signing_entity_sap_profit_center import (
    SigningEntitySapProfitCenterDetailSchema,
    SigningEntitySapProfitCenterPostByProfitCenterSchema,
    SigningEntitySapProfitCenterPostSchema,
)

signing_entity_sap_profit_center_api = Blueprint(
    'signing_entity_sap_profit_center_api', __name__
)


class SigningEntitySapProfitCenterCreateView(CreateView):
    """Admin POST: create a SE-PC junction row."""

    post_schema = SigningEntitySapProfitCenterPostSchema()

    def post(self, **kwargs):
        """Create a SigningEntitySapProfitCenter."""
        access_rule_decision = flask_request.verify_rules_access_standalone(request)
        if not access_rule_decision:
            return flaskify(
                response.create_error_response(
                    code=error.ERROR_CODE_AUTHORIZATION,
                    message='Unauthorized',
                    status=401,
                )
            )
        return super().post(**kwargs)

    def create_handler(self, **params):
        """Delegate to logic layer."""
        return logic.create_signing_entity_sap_profit_center(**params)


class SigningEntitySapProfitCenterItemView(ItemView):
    """Admin DELETE: soft-delete a SE-PC junction row."""

    model_class = models.SigningEntitySapProfitCenter
    object_detail_schema = SigningEntitySapProfitCenterDetailSchema()

    def delete(self, object_id):
        """Soft-delete a SigningEntitySapProfitCenter (blocked if in use)."""
        access_rule_decision = flask_request.verify_rules_access_standalone(request)
        if not access_rule_decision:
            return flaskify(
                response.create_error_response(
                    code=error.ERROR_CODE_AUTHORIZATION,
                    message='Unauthorized',
                    status=401,
                )
            )
        return flaskify(logic.delete_signing_entity_sap_profit_center(object_id))


signing_entity_sap_profit_center_api.add_url_rule(
    '/signing-entity-profit-center/',
    methods=['POST'],
    view_func=SigningEntitySapProfitCenterCreateView.as_view(
        'create_signing_entity_sap_profit_center'
    ),
)

signing_entity_sap_profit_center_api.add_url_rule(
    '/signing-entity-profit-center/<int:object_id>/',
    methods=['DELETE'],
    view_func=SigningEntitySapProfitCenterItemView.as_view(
        'signing_entity_sap_profit_center'
    ),
)


@signing_entity_sap_profit_center_api.route(
    '/reference-sap-profit-center/<int:sap_profit_center_id>/signing-entities/bulk',
    methods=['POST'],
)
@doc(
    tags=['Signing Entity SAP Profit Center Mappings'],
    summary='Bulk associate signing entities to a profit center',
    description='Bulk create or restore Signing Entity assignments for a specific SAP Profit Center.',
    responses={
        400: {'description': 'Invalid request payload or missing references.'},
        401: {'description': 'Authorization rules check failed.'},
        409: {'description': 'A mapping relationship already exists and is active.'},
    },
)
@use_kwargs(
    SigningEntitySapProfitCenterPostByProfitCenterSchema,
    location='json',
    required=True,
    apply=False,
)
@marshal_with(
    SigningEntitySapProfitCenterDetailSchema(many=True),
    code=201,
    description='Successfully created or restored the mappings.',
)
def bulk_associate_signing_entities(sap_profit_center_id: int):
    """Bulk create or restore Signing Entity assignments for a specific SAP Profit Center."""
    access_rule_decision = flask_request.verify_rules_access_standalone(request)
    if not access_rule_decision:
        return flaskify(
            response.create_error_response(
                code=error.ERROR_CODE_AUTHORIZATION,
                message='Unauthorized',
                status=401,
            )
        )
    processed_body = validated_request_body(
        SigningEntitySapProfitCenterPostByProfitCenterSchema()
    )
    return flaskify(
        logic.bulk_associate_signing_entities(
            sap_profit_center_id, processed_body['reference_signing_entity_ids']
        )
    )