"""Blueprint for Contract Advance API."""

from abacus_common_logic.views.create_view import CreateView
from abacus_common_logic.views.item_view import ItemView
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 contract as contract_logic, contract_advance as logic
from abacus_contract.schemas.contract_advance import ContractAdvancePostSchema
from abacus_contract.schemas.contract_advance import ContractAdvancePutSchema
from abacus_contract.schemas.contract_advance import ContractAdvanceSchema
from abacus_contract.utils import authorization


contract_advance_api = Blueprint('contract_advance_api', __name__)


class ContractAdvanceCreateView(CreateView):
    """Handles contract advance creation."""

    post_schema = ContractAdvancePostSchema()

    def create_handler(self, **params):
        """Create a contract advance."""
        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 logic.create_contract_advance(**params)


contract_advance_api.add_url_rule(
    '/contract/<int:contract_id>/advance/',
    methods=['POST'],
    view_func=ContractAdvanceCreateView.as_view('create_contract_advance')
)


@contract_advance_api.route(
    '/contract/<int:contract_id>/advances/',
    defaults={'status': None},
    methods=['GET']
)
@contract_advance_api.route(
    '/contract/<int:contract_id>/advances/<string:status>/',
    methods=['GET']
)
def get_advances_by_contract_id(contract_id: int, status: str):
    """GET a list of advances for a contract_id and status.

    Arg:
        contract_id(int): id of the contract
        status (str)(Optional): either pending or paid
    """
    access_rule_decision = flask_request.verify_rules_access_standalone(request)
    if not access_rule_decision:
        account_id = contract_logic.get_account_id_by_contract_id(contract_id)
        if not account_id:
            # Can't verify that user has access to something we can't find
            return flaskify(
                response.create_error_response(
                    code=error.ERROR_CODE_FORBIDDEN,
                    message=error.ERROR_MESSAGE_FORBIDDEN_USER,
                    status=403,
                )
            )
        else:
            authorized = authorization.pdp_authorize_many_accounts([account_id])
            if not authorized:
                return flaskify(
                    response.create_error_response(
                        code=error.ERROR_CODE_FORBIDDEN,
                        message=error.ERROR_MESSAGE_FORBIDDEN_USER,
                        status=403,
                    )
                )
    return flaskify(logic.get_contract_advances(contract_id, status, request.args))


class ContractAdvanceItemView(ItemView):
    """Handles update, delete and get operation on existing contract-advance."""

    model_class = models.ContractAdvance
    object_detail_schema = ContractAdvanceSchema()
    put_schema = ContractAdvancePutSchema()

    def get(self, object_id, **kwargs):
        """Handle contract_advance get."""
        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)

    def delete(self, object_id):
        """Handle contract_advance soft deletion."""
        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,
            ))
        obj = self.model_class.get_by_id_or_error(object_id)
        return flaskify(logic.delete_contract_advance(obj))

    def put(self, object_id, **kwargs):
        """Handle contract_advance update."""
        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().put(object_id, **kwargs)

    def update_handler(self, obj, **params):
        """Handle contract_advance update."""
        return logic.update_contract_advance(obj, **params)


contract_advance_api.add_url_rule(
    '/contract-advance/<int:object_id>/',
    methods=['GET', 'DELETE', 'PUT'],
    view_func=ContractAdvanceItemView.as_view('contract_advance')
)