from annoying.decorators import render_to
from django.contrib.auth.decorators import login_required
from django.http import JsonResponse
from django.shortcuts import redirect
from django.utils.decorators import method_decorator
from django.views.generic import TemplateView
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_POST
from lemoncurry import breadcrumbs, requests, utils
from urllib.parse import urlencode, urljoin, urlunparse, urlparse

from .. import tokens
from ..models import IndieAuthCode

breadcrumbs.add("lemonauth:indie", parent="home:index")


def canonical(url):
    if "//" not in url:
        url = "//" + url
    (scheme, netloc, path, params, query, fragment) = urlparse(url)
    if not scheme or scheme == "http":
        scheme = "https"
    if not path:
        path = "/"
    return urlunparse((scheme, netloc, path, params, query, fragment))


@method_decorator(csrf_exempt, name="dispatch")
class IndieView(TemplateView):
    template_name = "lemonauth/indie.html"
    required_params = ("client_id", "redirect_uri")

    @method_decorator(login_required)
    @method_decorator(render_to(template_name))
    def get(self, request):
        params = request.GET.dict()
        params.setdefault("response_type", "id")

        for param in self.required_params:
            if param not in params:
                return utils.bad_req("parameter {0} is required".format(param))

        me = request.user.full_url
        if "me" in params:
            param_me = canonical(params["me"])
            if me != param_me:
                return utils.forbid(
                    "you are logged in as {}, not as {}".format(me, param_me)
                )

        redirect_uri = urljoin(params["client_id"], params["redirect_uri"])

        type = params["response_type"]
        if type not in ("id", "code"):
            return utils.bad_req("unknown response_type: {0}".format(type))

        scopes = ()
        if type == "code":
            if "scope" not in params:
                return utils.bad_req("scopes required for code type")
            scopes = params["scope"].split(" ")

        client = requests.mf2(params["client_id"])
        rels = client.to_dict()["rel-urls"].get(redirect_uri, {}).get("rels", ())
        verified = "redirect_uri" in rels

        try:
            app = client.to_dict(filter_by_type="h-x-app")[0]["properties"]
        except IndexError:
            app = None

        return {
            "app": app,
            "me": me,
            "redirect_uri": redirect_uri,
            "verified": verified,
            "params": params,
            "scopes": scopes,
            "title": "indieauth from {client_id}".format(**params),
        }

    def post(self, request):
        post = request.POST.dict()
        try:
            code = IndieAuthCode.objects.get(pk=post.get("code"))
        except IndieAuthCode.DoesNotExist:
            # if anything at all goes wrong when decoding the auth code, bail
            # out immediately.
            return utils.forbid("invalid auth code")
        code.delete()
        if code.expired:
            return utils.forbid("invalid auth code")

        if code.response_type != "id":
            return utils.bad_req("this endpoint only supports response_type=id")
        if code.client_id != post.get("client_id"):
            return utils.forbid("client id did not match")
        if code.redirect_uri != post.get("redirect_uri"):
            return utils.forbid("redirect uri did not match")

        # If we got here, it's valid! Yay!
        return utils.choose_type(
            request,
            {"me": code.me},
            {
                "application/x-www-form-urlencoded": utils.form_encoded_response,
                "application/json": JsonResponse,
            },
        )


@login_required
@require_POST
def approve(request):
    params = {
        "me": urljoin(utils.origin(request), request.user.url),
        "code": tokens.gen_auth_code(request),
    }
    if "state" in request.POST:
        params["state"] = request.POST["state"]

    uri = request.POST["redirect_uri"]
    sep = "&" if "?" in uri else "?"
    return redirect(uri + sep + urlencode(params))