"""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, g, 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_term as contract_term_logic,
    contract_term_condition as logic,
)
from abacus_contract.schemas.contract_term_condition import (
    ContractTermConditionPostSchema,
    ContractTermConditionPutSchema,
)
from abacus_contract.utils import authorization
from abacus_contract.utils.dataloader import account_scoped_dataloader
from core.config import ows_client

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))


@contract_term_condition_api.route(
    '/contract-term-conditions/dataloader', methods=['POST']
)
def get_conditions_by_term_ids_dataloader():
    """Batch-fetch contract term conditions for the given contract_term_ids."""
    return account_scoped_dataloader(
        entity_name='ContractTerm',
        resolve_accounts=contract_term_logic.get_account_ids_by_contract_term_ids,
        fetch_records=logic.get_condition_records_by_term_ids,
        key_field='contract_term_id',
        as_list=True,
    )