"""Blueprint for run controller contract API."""

from abacus_common_logic.views.create_view import CreateView
from abacus_common_logic.views.validations import validated_request_body
from flask import Blueprint, request
from owsrequest import flask_request
from owsresponse import response
from owsresponse.adaptors.flask import flaskify

from royalties.constants import error
from royalties.logic import contract as contract_logic, run_controller_contract as logic
from royalties.schemas.run_controller_contract import (
    RunControllerContractPostSchema,
    RunControllerContractPutSchema,
)
from royalties.utils import authorization
from royalties.utils.format_error import validation_error
from royalties.utils.request import get_optional_numeric_list_from_params

run_controller_contract_api = Blueprint('run_controller_contract_api', __name__)


class RunControllerContractCreateView(CreateView):
    """Handles run controller contract creation."""

    post_schema = RunControllerContractPostSchema(
        exclude=('run_controller_contract_id',)
    )

    def post(self, **kwargs):
        """Create run controller contract."""
        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):
        """Create run controller."""
        return logic.create_run_controller_contract(**params)


run_controller_contract_api.add_url_rule(
    '/run-controller/contract',
    methods=['POST'],
    view_func=RunControllerContractCreateView.as_view('create_run_controller_contract'),
)


@run_controller_contract_api.route(
    '/run-controllers/contracts/account/<int:account_id>', methods=['GET']
)
def get_run_controller_contracts_by_account(account_id):
    """Get run_controller_contracts by a specified account_id."""
    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,
            )
        )
    contract_type = request.args.get('contract_type')
    return flaskify(
        logic.get_run_controller_contracts_by_account(account_id, contract_type)
    )


@run_controller_contract_api.route(
    '/run-controllers/contracts/dataloader', methods=['POST']
)
def get_run_controller_contracts_dataloaded():
    """Get run controller contracts by a list of contract_ids.

    Note: This endpoint uses a POST method to allow
    for a list of ids to be passed in the body of the request.
    """
    try:
        contract_ids = get_optional_numeric_list_from_params() or []
    except ValueError:
        return flaskify(
            validation_error(
                error.ERROR_INVALID_IDS.format(object='Run Controller Contract')
            )
        )
    access_rule_decision = flask_request.verify_rules_access_standalone(request)
    if not access_rule_decision:
        account_ids = contract_logic.get_account_ids_by_contract_ids(contract_ids)
        authorized = authorization.pdp_authorize_many_accounts(account_ids)
        if not authorized:
            return flaskify(
                response.create_error_response(
                    code=error.ERROR_CODE_AUTHORIZATION,
                    message=error.ERROR_MESSAGE_FORBIDDEN_USER,
                    status=403,
                )
            )
    return flaskify(
        logic.get_contracts_run_controllers_with_dataload_format(contract_ids)
    )


@run_controller_contract_api.route(
    '/run-controller-contracts',
    methods=['PUT'],
)
def update_run_controller_contract():
    """Update run controller contract by contract_id."""
    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,
            )
        )
    update_request_body = validated_request_body(RunControllerContractPutSchema())
    return flaskify(logic.update_run_controller_contract(**update_request_body))