import flask
from webargs import fields
from webargs.flaskparser import use_kwargs

from atlas_um import pgdb
from atlas_um.auth.claims import Role
from atlas_um.auth.decorators import claims_required
from atlas_um.auth.utils import current_user
from atlas_um.helpers.ordering import QueryOrdering
from atlas_um.helpers.pagination import QueryPagination
from atlas_um.settings import Settings
from atlas_um.tokens.bearer_tokens import M2MBearerToken
from .forms import ApplicationForm
from .services import (
    CreateApplicationService,
    UpdateApplicationService,
    ResetClientSecretService,
    DeleteApplicationService,
)

applications = flask.Blueprint("applications", __name__)


@applications.route("/", methods=["GET"])
@claims_required([Role(Role.Values.admin), Role(Role.Values.developer)])
@use_kwargs(
    {
        "page": fields.Int(load_default=1),
        "per_page": fields.Int(load_default=Settings.ITEMS_PER_PAGE),
        "order": fields.Str(load_default=""),
    },
    location="query",
)
def list(page, per_page, order):
    applications = pgdb.Application.query.active()
    if not current_user.is_admin:
        applications = applications.by_dna_account(current_user.dna_account)

    ordering = QueryOrdering(
        applications,
        [
            pgdb.Application.dna_account_id,
            pgdb.Application.name,
            pgdb.Application.client_id,
            pgdb.Application.resource_group_id,
            pgdb.Application.audience,
        ],
        order,
    )
    applications = ordering.query
    pagination = QueryPagination(
        page=page, per_page=per_page, query=applications
    )

    return flask.render_template(
        "applications/list_applications.html",
        applications=pagination.items,
        ordering=ordering,
        pagination=pagination,
    )


@applications.route("/create", methods=["GET", "POST"])
@claims_required([Role(Role.Values.admin), Role(Role.Values.developer)])
def create():
    form = ApplicationForm()
    if form.validate_on_submit():
        result = CreateApplicationService.execute(
            dna_account=current_user.dna_account, **form.data
        )
        flask.flash("The application is successfully created.", "positive")
        return flask.redirect(
            flask.url_for(
                "applications.update", application_id=result.value.id
            )
        )
    return flask.render_template(
        "applications/create_application.html", form=form
    )


@applications.route("/<application_id>", methods=["GET", "POST"])
@claims_required([Role(Role.Values.admin), Role(Role.Values.developer)])
def update(application_id):
    query = pgdb.Application.query.active()
    if not current_user.is_admin:
        query = query.by_dna_account(current_user.dna_account)
    application = query.by_id(application_id).first_or_404()

    form = ApplicationForm(obj=application)
    if form.validate_on_submit():
        UpdateApplicationService.execute(application=application, **form.data)
        flask.flash("The application is successfully updated.", "positive")
        return flask.redirect(flask.url_for("applications.list"))

    return flask.render_template(
        "applications/update_application.html",
        application=application,
        form=form,
    )


@applications.route("/<application_id>/delete", methods=["POST"])
@claims_required([Role(Role.Values.admin), Role(Role.Values.developer)])
def delete(application_id):
    query = pgdb.Application.query.active()
    if not current_user.is_admin:
        query = query.by_dna_account(current_user.dna_account)
    application = query.by_id(application_id).first_or_404()

    DeleteApplicationService.execute(application=application)
    flask.flash("The application is successfully deleted.", "positive")
    return flask.redirect(flask.url_for("applications.list"))


@applications.route("/<application_id>/reset_secret", methods=["POST"])
@claims_required([Role(Role.Values.admin), Role(Role.Values.developer)])
def reset_secret(application_id):
    query = pgdb.Application.query.active()
    if not current_user.is_admin:
        query = query.by_dna_account(current_user.dna_account)
    application = query.by_id(application_id).first_or_404()

    ResetClientSecretService.execute(application=application)
    flask.flash("The client secret is successfully updated.", "positive")
    return flask.redirect(
        flask.url_for("applications.update", application_id=application_id)
    )


@applications.route("/<application_id>/token", methods=["GET"])
@claims_required([Role(Role.Values.admin), Role(Role.Values.developer)])
def get_token(application_id):
    query = pgdb.Application.query.active()
    if not current_user.is_admin:
        query = query.by_dna_account(current_user.dna_account)
    application = query.by_id(application_id).first_or_404()

    token = M2MBearerToken(
        application,
        ttl=flask.current_app.config.get("SHORT_LIVING_M2M_TOKEN_TTL"),
    )
    return flask.render_template(
        "applications/components/token_modal_content.html",
        token=token.encode(),
    )