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

from abacus_common_logic.views.create_view import CreateView
from abacus_common_logic.views.item_view import ItemView
from abacus_common_logic.views.list_view import ListView
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 as logic
from royalties.models import RunController
from royalties.schemas.run_controller import (
    BaseRunControllerSchema,
    RunControllerDetailSchema,
    RunControllerListEntrySchema,
)
from royalties.utils import authorization

run_controller_api = Blueprint('run_controller_api', __name__)


class RunControllerItemView(ItemView):
    """View for existing run controllers."""

    model_class = RunController
    object_detail_schema = RunControllerDetailSchema()

    def get(self, object_id, **kwargs):
        """Get run controller by 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,
                )
            )
        return super().get(object_id, **kwargs)


class RunControllerCreateView(CreateView):
    """Handles run controller creation."""

    post_schema = BaseRunControllerSchema()

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


class RunControllerListView(ListView):
    """View for listing run controllers."""

    model_class = RunController
    list_entry_schema = RunControllerListEntrySchema()

    def get(self):
        """GET request handler to fetch list of run controllers."""
        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,
                )
            )
        offset = max(request.args.get('offset', default=0, type=int), 0)
        limit = max(request.args.get('limit', default=100, type=int), 1)
        results = self.list_entry_schema.dump(
            self.get_page(offset=offset, limit=limit), many=True
        )
        count = self.base_list_query().count()
        return flaskify(response.Response({'items': results, 'total_count': count}))

    def base_list_query(self):
        """Override ItemView's base_list_query."""
        contract_type = request.args.get('contract_type')
        active_only = request.args.get('active_only')
        active_only = True if active_only and active_only.lower() == 'true' else False
        return RunController.base_list_query(contract_type, active_only)


@run_controller_api.route(
    '/run-controller-by-contract/<int:contract_id>', methods=['GET']
)
def get_contract_run_controllers(contract_id):
    """Get run controller associated to given 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_id])
        if account_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,
                    )
                )
        else:
            return flaskify(response.create_not_found_response())
    return logic.get_contract_run_controller(contract_id)


run_controller_api.add_url_rule(
    '/run-controller/<int:object_id>',
    methods=['GET'],
    view_func=RunControllerItemView.as_view('runcontroller'),
)

run_controller_api.add_url_rule(
    '/run-controller',
    methods=['POST'],
    view_func=RunControllerCreateView.as_view('create_runcontroller'),
)

run_controller_api.add_url_rule(
    '/run-controllers',
    methods=['GET'],
    view_func=RunControllerListView.as_view('runcontrollerlist'),
)