"""Contract Flowthrough handlers."""

from abacus_common_logic.constants.error import ERROR_ENTITY_DOES_NOT_EXIST
from abacus_common_logic.views.create_view import CreateView
from abacus_common_logic.views.item_view import ItemView
from flask import Blueprint
from flask import request
from owsrequest import flask_request
from owsresponse import response
from owsresponse.adaptors.flask import flaskify

from abacus_contract.constants import error
from abacus_contract.logic import (
    contract as contract_logic, contract_flowthrough as logic
)
from abacus_contract.models.contract_flowthrough import ContractFlowthrough
from abacus_contract.schemas.contract_flowthrough import ContractFlowthroughDetailSchema
from abacus_contract.schemas.contract_flowthrough import ContractFlowthroughPostSchema
from abacus_contract.schemas.contract_flowthrough import ContractFlowthroughPutSchema
from abacus_contract.utils import authorization


contract_flowthrough_api = Blueprint(
    'contract_flowthrough_api',
    __name__
)


class ContractFlowthroughItemView(ItemView):
    """View for existing contract_flowthrough."""

    model_class = ContractFlowthrough
    object_detail_schema = ContractFlowthroughDetailSchema()
    put_schema = ContractFlowthroughPutSchema()

    def get(self, object_id):
        """Find object by its id or return an error."""
        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(object_id)
        if not obj or (obj.deleted_at is not None or obj.deleted_by is not None):
            return flaskify(response.create_not_found_response(
                message=ERROR_ENTITY_DOES_NOT_EXIST.format(
                    object_type='ContractFlowthrough',
                    object_id=object_id
                )
            ))
        body = self.object_detail_schema.dump(obj)
        return flaskify(response.Response(message=body, status=200))

    def delete(self, object_id):
        """Delete a contract_flowthrough."""
        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, 404)
        return flaskify(logic.soft_delete_contract_flowthrough(obj))

    def put(self, object_id, **kwargs):
        """Update contract_flowthrough 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,
            ))

        obj = self.model_class.get_by_id(object_id)
        if not obj or (obj.deleted_at is not None or obj.deleted_by is not None):
            return flaskify(response.create_not_found_response(
                message=ERROR_ENTITY_DOES_NOT_EXIST.format(
                    object_type='ContractFlowthrough',
                    object_id=object_id
                )
            ))
        return super().put(object_id, **kwargs)

    def update_handler(self, obj, **params):
        """Handle contract_flowthrough updates."""
        return logic.update_contract_flowthrough(obj, **params)


contract_flowthrough_api.add_url_rule(
    '/contract-flowthrough/<int:object_id>/',
    methods=['GET', 'DELETE', 'PUT'],
    view_func=ContractFlowthroughItemView.as_view('contract_flowthrough')
)


class ContractFlowthroughCreateView(CreateView):
    """Handles contract_flowthrough creation."""

    post_schema = ContractFlowthroughPostSchema()

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


contract_flowthrough_api.add_url_rule(
    '/contract/<int:contract_id>/contract-flowthrough/',
    view_func=ContractFlowthroughCreateView.as_view(
        'create_contract_flowthrough'
    )
)


@contract_flowthrough_api.route(
    '/contract/<int:contract_id>/contract-flowthrough/',
    methods=['GET']
)
def get_contract_flowthrough_by_contract_id(contract_id: int):
    """GET a contract_flowthrough by contract_id.

    Arg:
        contract_id(int): id of the contract
    """
    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_AUTHORIZATION,
                    message=error.ERROR_MESSAGE_FORBIDDEN_USER,
                    status=403,
                )
            )
        authorized = authorization.pdp_authorize_many_accounts(
            [account_id],
        )
        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_contract_flowthrough_by_contract_id(contract_id)
    )