"""Contract Term Condition handlers."""

from abacus_common_logic.utils.authorization import permissions_authorize_many_accounts
from abacus_common_logic.views.validations import validated_request_body
from flask import Blueprint
from flask import g
from flask import request
from owsrequest import flask_request
from owsresponse import response
from owsresponse.adaptors.flask import flaskify

from abacus_contract.config import ows_client
from abacus_contract.constants import error
from abacus_contract.logic import (
    contract_term as contract_term_logic,
    contract_term_condition as logic
)
from abacus_contract.schemas.contract_term_condition import \
    ContractTermConditionPostSchema
from abacus_contract.schemas.contract_term_condition import \
    ContractTermConditionPutSchema
from abacus_contract.utils import authorization


contract_term_condition_api = Blueprint('contract_term_condition_api', __name__)


@contract_term_condition_api.route(
    '/contract-term/<int:contract_term_id>/conditions',
    methods=['POST']
)
def bulk_create_contract_term_conditions(contract_term_id):
    """Create contract term conditions."""
    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,
        ))
    post_schema = ContractTermConditionPostSchema(many=True)
    params = validated_request_body(post_schema)
    return flaskify(logic.create_contract_term_conditions(contract_term_id, params))


@contract_term_condition_api.route(
    '/contract-term-conditions/soft-delete',
    methods=['PUT']
)
def bulk_soft_delete_contract_term_conditions():
    """Soft delete one or more specified contract_term_conditions."""
    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_term_condition_ids = request.get_json()
    return flaskify(
        logic.soft_delete_contract_term_conditions(contract_term_condition_ids)
    )


@contract_term_condition_api.route(
    '/contract-term/<int:contract_term_id>/conditions',
    methods=['PUT']
)
def bulk_update_contract_term_conditions(contract_term_id):
    """Update contract term conditions."""
    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,
        ))
    put_schema = ContractTermConditionPutSchema(many=True)
    params = validated_request_body(put_schema)
    return flaskify(logic.update_contract_term_conditions(contract_term_id, params))


@contract_term_condition_api.route(
    '/contract-term/<int:contract_term_id>/conditions',
    methods=['GET']
)
def get_conditions_by_term_id(contract_term_id):
    """Handle getting conditions associated to the specified contract term."""
    account_id = contract_term_logic.get_account_id_by_contract_term_id(
        contract_term_id
    )
    if not account_id:
        return flaskify(
            response.create_error_response(
                code=error.ERROR_CODE_NOT_FOUND,
                message=error.ERROR_ACCOUNT_NOT_FOUND_FOR_CONTRACT,
                status=404,
            )
        )

    access_rule_decision = flask_request.verify_rules_access_standalone(request)
    if not access_rule_decision:
        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,
                )
            )

    authorized = permissions_authorize_many_accounts(
        ows_client,
        g.request_context.profile_type,
        g.request_context.profile_id,
        [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_conditions_by_term_id(contract_term_id))