from django.shortcuts import render
from django.views import View
from django.http import HttpResponse, HttpResponseRedirect
from django.template.response import TemplateResponse
from django.contrib.auth.mixins import LoginRequiredMixin
import re
from .models import Track, Artist, Album, Vote
from .utils import from_json, get_unvoted
from . import spotify
from .tasks import get_banter

spt = spotify.Spotify()

class AuthView(View):
    def get(self, request):
        if request.user.is_authenticated:
            #return TemplateResponse(request, "Nominate.html", {})
            return HttpResponseRedirect('/vote')
        else:
            return TemplateResponse(request, "Login.html", {})

class VoteView(LoginRequiredMixin, View):
    def get(self, request, error=None):
        track = get_unvoted(request.user)
        return TemplateResponse(request, "Vote.html", {"track": track, "error": error})
    def post(self, request):
        try:
            spotify_id = self.request.POST['spotify_id']
            score = int(self.request.POST['vote'])
            score = min(max(-2, score), 2)
            track = Track.objects.get(pk=spotify_id)
            try:
                Vote.objects.get(user=request.user, track=track)
            except Vote.DoesNotExist:
                pass
            else:
                raise Exception(f"{request.user} already voted for {track}")
            Vote.objects.create(track=track, user=request.user, points=score)
            print(track)
        except Exception as e:
            print(e)
            return self.get(request, str(e))
        else:
            return self.get(request)

class NominateView(LoginRequiredMixin, View):
    def get(self, request):
        return TemplateResponse(request, "Nominate.html", {})
    def post(self, request):
        spotify_link = self.request.POST['spotify_link']
        m = re.match(r"^https:\/\/open.spotify.com\/track\/(\w+)\??", spotify_link)
        spotify_id = m.group(1)
        try:
            track = Track.all_tracks.get(pk=spotify_id)

            if track.old:
                return TemplateResponse(request, "Nominate.html", {
                    "warning": "Hey een klassieker.",
                    "nominated": track
                })
            return TemplateResponse(request, "Nominate.html", {
                "error": "Deze is al genomineerd dit jaar, probeer eens iets anders.",
                "nominated": track
            })
        except Track.DoesNotExist:
            json = spt.get_song_info(spotify_id)

            # Album artists
            album_artists = []
            for artist in json["album"]["artists"]:
                album_artists.append(from_json(Artist, artist))
            del json["album"]["artists"]

            # Album
            album = from_json(Album, json["album"])
            album.image_url = json["album"]["images"][0]["url"]
            album.save()
            del json["album"]
            for artist in album_artists:
                album.artists.add(artist)

            # Track artists
            track_artists = []
            for artist in json["artists"]:
                track_artists.append(from_json(Artist, artist))
            del json["artists"]

            # Track
            track = from_json(Track, json)
            for artist in track_artists:
                track.artists.add(artist)
            track.save()
            dup = track.is_duplicate_of()
            if dup:
                track.delete()
                return TemplateResponse(request, "Nominate.html", {
                    "error": f"Die hadden we al knul.",
                    "nominated": dup
                })
            track.album = album
            track.save()
            get_banter.delay(track.id)
            
            return TemplateResponse(request, "Nominate.html", {"nominated": track})

class BanterView(LoginRequiredMixin, View):
    def get(self, request, spotify_id):
        try:
            track = Track.objects.get(pk=spotify_id)
            return TemplateResponse(request, "Banter.html", {
                "track": track,
                "waiting": ["Nog even..", "Bijna klaar.", "Oké...", "Interessant", "Momentje"]
            })
        except Track.DoesNotExist:
            return HttpResponse("???")