"""Blueprint for ContractParty 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_party as logic
from abacus_contract.schemas.contract_party import (
    ContractPartyDetailSchema,
    ContractPartyPostSchema,
)
from abacus_contract.utils import authorization

contract_party_api = Blueprint('contract_party_api', __name__)


class ContractPartyCreateView(CreateView):
    """Handles contract_party creation."""

    post_schema = ContractPartyPostSchema()

    def post(self, **kwargs):
        """Create a contract_party."""
        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 a contract_party."""
        return logic.create_contract_party(**params)


class ContractPartyItemView(ItemView):
    """Handles delete operation."""

    model_class = models.ContractParty
    object_detail_schema = ContractPartyDetailSchema()

    def delete(self, object_id):
        """Soft delete a contract_party."""
        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_party(obj))


contract_party_api.add_url_rule(
    '/contract-party/',
    methods=['POST'],
    view_func=ContractPartyCreateView.as_view('create_contract_party'),
)


@contract_party_api.route(
    '/contract/<int:contract_id>/parties/',
    defaults={'target_type': None},
    methods=['GET'],
)
@contract_party_api.route(
    '/contract/<int:contract_id>/<string:target_type>/parties', methods=['GET']
)
def get_contract_parties(contract_id: int, target_type: str):
    """GET a list of contract parties.

    Arg:
        contract_id(int): id of the contract
        target_type (str)(Optional): must be one of 'contributor', 'label'
    """
    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_parties(contract_id, target_type, request.args))


contract_party_api.add_url_rule(
    '/contract-party/<int:object_id>/',
    methods=['DELETE'],
    view_func=ContractPartyItemView.as_view('contract_party'),
)