"""Blueprint for Reference Payoneer Program API."""

from abacus_common_logic.views.item_view import ItemView
from abacus_common_logic.views.list_view import ListView
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_account.constants import error
from abacus_account.logic import reference_payoneer_program as logic
from abacus_account.models import ReferencePayoneerProgram
from abacus_account.schemas.reference_payoneer_program import \
    ReferencePayoneerProgramSchema
from abacus_account.utils.authorization import authorize_resource
from abacus_account.utils.format_error import validation_error

reference_payoneer_program_api = Blueprint('reference_payoneer_program_api', __name__)


class ReferencePayoneerProgramList(ListView):
    """View for listing Payoneer Programs."""

    model_class = ReferencePayoneerProgram
    list_entry_schema = ReferencePayoneerProgramSchema()

    def get(self):
        """GET payoneer programs."""
        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=403,
            ))
        return flaskify(logic.get_payoneer_programs())


class ReferencePayoneerProgramItemView(ItemView):
    """View for finding a reference_payoneer_program by ID."""

    model_class = ReferencePayoneerProgram
    object_detail_schema = ReferencePayoneerProgramSchema()

    def get(self, object_id, **kwargs):
        """GET reference_payoneer_program by ID."""
        access_rule_decision = flask_request.verify_rules_access_standalone(request)
        if not access_rule_decision:
            authorized = authorize_resource(object_id, 'payoneer_program')
            if not authorized:
                return flaskify(response.create_error_response(
                    code=error.ERROR_CODE_AUTHORIZATION,
                    message='Unauthorized', status=403,
                ))
        return super().get(object_id, **kwargs)


reference_payoneer_program_api.add_url_rule(
    '/payoneer-program',
    methods=['GET'],
    view_func=ReferencePayoneerProgramList.as_view('list_payoneer_programs'))


reference_payoneer_program_api.add_url_rule(
    '/payoneer-program/<int:object_id>',
    methods=['GET'],
    view_func=ReferencePayoneerProgramItemView.as_view('reference_payoneer_program')
)


# This route is deprecated and will be removed in future in favor
# of next one with payment-type.
@reference_payoneer_program_api.route(
    '/payoneer-program/'
    'payment-entity/<int:payment_entity_id>/'
    'currency/<string:currency_code>/'
    'agreement-type/<int:agreement_type_id>',
    methods=['GET']
)
@reference_payoneer_program_api.route(
    '/payoneer-program/'
    'payment-entity/<int:payment_entity_id>/'
    'currency/<string:currency_code>/'
    'agreement-type/<int:agreement_type_id>/'
    'payment-type/<int:reference_payment_type_id>',
    methods=['GET']
)
def get_payoneer_program(
    payment_entity_id, currency_code, agreement_type_id, reference_payment_type_id=None
):
    """Endpoint to GET payment_entity_payoneer_programs for a payment entity."""
    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=403,
        ))

    currency_code = currency_code.upper()
    # TODO: Add reference_payment_type_id as well when deprecated route will be removed.
    if not payment_entity_id or not currency_code or not agreement_type_id:
        return flaskify(validation_error(error.PARAMS_REQUIRED_MISSING.format(
            params_string='payment_entity_id,currency_code,payment_type_id')))
    return flaskify(
        logic.get_payoneer_program(
            currency_code=currency_code,
            agreement_type_id=agreement_type_id,
            payment_entity_id=payment_entity_id,
            reference_payment_type_id=reference_payment_type_id
        )
    )


@reference_payoneer_program_api.route(
    '/payoneer-program-move-type',
    methods=['GET']
)
def get_payoneer_program_move_type():
    """Endpoint to resolve move type for a payoneer program transition."""
    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=403,
        ))

    from_program_id = request.args.get('from_program_id', type=int)
    to_program_id = request.args.get('to_program_id', type=int)

    if from_program_id is None or to_program_id is None:
        return flaskify(validation_error(error.PARAMS_REQUIRED_MISSING.format(
            params_string='from_program_id,to_program_id')))

    return flaskify(
        logic.get_payoneer_program_move_type(
            from_program_id=from_program_id,
            to_program_id=to_program_id
        )
    )