"""Blueprint for Ledger Account API."""

from abacus_common_logic.utils.authorization import permissions_authorize_many_accounts
from abacus_common_logic.views.list_view import ListView
from flask import Blueprint, g, request
from owsrequest import flask_request
from owsresponse import response
from owsresponse.adaptors.flask import flaskify

from ledger.config import ows_client
from ledger.constants.constants import DEFAULT_PAGE_LIMIT, DEFAULT_PAGE_OFFSET
from ledger.constants.error import (
    ERROR_CODE_AUTHORIZATION,
    ERROR_CODE_FORBIDDEN,
    ERROR_MESSAGE_FORBIDDEN_USER,
)
from ledger.logic import ledger_account as logic
from ledger.models.ledger_account import LedgerAccount
from ledger.schemas.ledger_account import LedgerAccountListSchema
from ledger.utils.authorization import pdp_authorize_resource
from ledger.utils.request import validate_pagination_params

ledger_account_api = Blueprint('ledger_account_api', __name__)


class LedgerAccountListView(ListView):
    """List view for ledger_account."""

    model_class = LedgerAccount
    list_entry_schema = LedgerAccountListSchema

    def get(self, account_id: int):
        """Get a paginated list of ledger_account data for a specified account.

        Args:
            account_id (int): ID of the account
        """
        access_rule_decision = flask_request.verify_rules_access_standalone(request)
        if not access_rule_decision:
            authorized = pdp_authorize_resource(account_id)
            if not authorized:
                return flaskify(
                    response.create_error_response(
                        code=ERROR_CODE_AUTHORIZATION,
                        message='Unauthorized',
                        status=403,
                    )
                )

        limit = request.args.get('limit', DEFAULT_PAGE_LIMIT)
        offset = request.args.get('offset', DEFAULT_PAGE_OFFSET)
        pagination_params = validate_pagination_params(limit, offset)
        items, total_count = LedgerAccount.get_ledger_account_info(
            account_id, **pagination_params
        )
        message = {
            'items': LedgerAccountListSchema(many=True).dump(items),
            'total_count': total_count,
        }
        return flaskify(response.Response(message=message, status=200))


ledger_account_api.add_url_rule(
    '/ledger-accounts/account/<int:account_id>',
    methods=['GET'],
    view_func=LedgerAccountListView.as_view('ledger_account_list'),
)


@ledger_account_api.route('/ledger-account/account/<int:account_id>', methods=['GET'])
def get_ledger_info(account_id):
    """Endpoint to GET ledger info for a specified account."""
    access_rule_decision = flask_request.verify_rules_access_standalone(request)
    if not access_rule_decision:
        return flaskify(
            response.create_error_response(
                code=ERROR_CODE_AUTHORIZATION,
                message='Unauthorized',
                status=403,
            )
        )
    return flaskify(logic.get_ledger_account_info(account_id))


@ledger_account_api.route(
    '/ledger-account/account/<int:account_id>/current-balance', methods=['GET']
)
def get_current_balance(account_id):
    """Endpoint to GET current balance of a account."""
    access_rule_decision = flask_request.verify_rules_access_standalone(request)
    if not access_rule_decision:
        return flaskify(
            response.create_error_response(
                code=ERROR_CODE_AUTHORIZATION,
                message='Unauthorized',
                status=403,
            )
        )

    account_access = permissions_authorize_many_accounts(
        ows_client,
        g.request_context.profile_type,
        g.request_context.profile_id,
        [account_id],
    )

    if not account_access:
        return flaskify(
            response.create_error_response(
                code=ERROR_CODE_FORBIDDEN,
                message=ERROR_MESSAGE_FORBIDDEN_USER,
                status=403,
            )
        )

    return flaskify(logic.get_current_balance(account_id))


# TO BE DEPRECATED
# This endpoint is used by lambda-abacus-accounting-period-close
# (dczinsky)
@ledger_account_api.route(
    '/ledger-account/accounting-period/<int:accounting_period_id>/accounts',
    methods=['GET'],
)
def get_ledger_accounts(accounting_period_id):
    """Endpoint to GET ledger accounts for a specified accounting period."""
    access_rule_decision = flask_request.verify_rules_access_standalone(request)
    if not access_rule_decision:
        return flaskify(
            response.create_error_response(
                code=ERROR_CODE_AUTHORIZATION,
                message='Unauthorized',
                status=403,
            )
        )
    return flaskify(
        logic.get_ledger_accounts_by_acc_period_id(accounting_period_id, request.args)
    )