import json

from django.conf import settings
from django.contrib.auth.forms import SetPasswordForm
from django.contrib.auth.tokens import default_token_generator
from django.contrib.auth.views import LoginView as DjangoLoginView
from django.contrib.sites.shortcuts import get_current_site
from django.core.mail import EmailMessage
from django.db.models import Q
from django.forms import formset_factory
from django.http import HttpResponseRedirect
from django.shortcuts import resolve_url
from django.template.loader import render_to_string
from django.urls import reverse, reverse_lazy
from django.utils import timezone
from django.utils.encoding import force_bytes, force_text
from django.utils.http import urlsafe_base64_encode, urlsafe_base64_decode
from django.utils.translation import ugettext_lazy as _
from django.views.generic import UpdateView, ListView, DetailView, FormView

from memberzone.models import MemberTask, MemberTaskRegistration, MemberDownloadFile, Profile


class MemeberTaskQuerysetMixin(object):
    def get_queryset(self):
        return MemberTask.objects.filter(groups__in=self.request.user.groups.all()).distinct()


class OverviewView(MemeberTaskQuerysetMixin, ListView):
    template_name = 'memberzone/overview.html'
    open_tasks = None

    paginate_by = 3

    def get_title(self):
        return _('Grüezi, {first_name} {last_name}').format(
            first_name=self.request.user.first_name,
            last_name=self.request.user.last_name,
        )

    def get_download_sections(self):
        file_list = MemberDownloadFile.objects.filter(groups__in=self.request.user.groups.all())
        sections = {}
        for file in file_list:
            if not sections.get(file.section_id, None):
                sections[file.section_id] = {
                    'section': file.section,
                    'items': []
                }
            sections[file.section_id]['items'].append(file)

        sections_list = [{'title': x['section'].title, 'items': x['items'], 'ordering': x['section'].ordering} for x in
                sections.values()]

        return sorted(sections_list, key=lambda x: x['ordering'])

    def get_queryset(self):
        queryset = super(OverviewView, self).get_queryset()
        return queryset.exclude(pk__in=self.get_open_tasks().values_list('pk', flat=True))

    def get_open_tasks(self):
        yesterday = timezone.now() - timezone.timedelta(days=1)
        all_user_registrations = MemberTaskRegistration.objects.filter(user=self.request.user, cdate__lte=yesterday)
        queryset = MemeberTaskQuerysetMixin.get_queryset(self)
        queryset.exclude(registrations__in=all_user_registrations).order_by('-registrations__cdate')
        return queryset

    def get_context_data(self, **kwargs):
        context = super(OverviewView, self).get_context_data(**kwargs)
        context.update({
            'download_sections': self.get_download_sections(),
            'open_tasks': None if self.request.GET.get(self.page_kwarg, None) else self.get_open_tasks(),
        })
        return context


class MemberTaskDetailView(MemeberTaskQuerysetMixin, DetailView):
    template_name = 'memberzone/task.html'
    model = MemberTask

    def get_title(self):
        return self.object.title

    def get_description(self):
        return self.object.sub_title

    def get_formset(self):
        try:
            MemberTaskRegistration.objects.get(task=self.object, user=self.request.user)
        except MemberTaskRegistration.DoesNotExist:
            MemeberTaskFormset = formset_factory(
                self.object.form_class,
                extra=0,
                min_num=1,
                max_num=self.object.max_num,
                can_delete=True
            )
            formset_kwargs = {}
            if self.request.method == 'POST':
                formset_kwargs.update({
                    'data': self.request.POST
                })
            return MemeberTaskFormset(**formset_kwargs)
        else:
            return None

    def formset_valid(self, formset):
        registration = MemberTaskRegistration.objects.create(
            task=self.object,
            user=self.request.user,
            form_data=json.dumps(formset.cleaned_data)
        )
        if registration.task.fields.count() > 0:
            self.send_confirmation_email(registration=registration)
        return HttpResponseRedirect(reverse('memberzone:task_success', args=[self.object.slug]))

    def formset_invalid(self, formset):
        return self.render_to_response(context=self.get_context_data(formset=formset, object=self.object))

    def get(self, request, *args, **kwargs):
        self.object = self.get_object()
        formset = self.get_formset()
        return self.render_to_response(context=self.get_context_data(formset=formset, object=self.object))

    def send_confirmation_email(self, registration):
        subject = _('Anmeldebestätigung: {}').format(registration.task.title)

        confirmation_data = []
        for data_set in json.loads(registration.form_data):
            confirmation_data_set = []
            for field in registration.task.fields.all():
                value = data_set.get(field.name.replace('-', '_'), '')
                if isinstance(value, list):
                    value = ','.join(value)
                confirmation_data_set.append((field.label, value,))
            confirmation_data.append(confirmation_data_set)

        message = render_to_string('memberzone/email/member_registration_confirmation_email.html', {
            'data': confirmation_data,
            'subject': subject,
        })
        msg = EmailMessage(subject, message, settings.DEFAULT_FROM_EMAIL, to=[registration.user.email])
        msg.content_subtype = "html"
        # msg.send()

    def post(self, request, *args, **kwargs):
        self.object = self.get_object()
        formset = self.get_formset()
        if formset.is_valid():
            return self.formset_valid(formset)
        else:
            return self.formset_invalid(formset)


class MemberTaskDetailSuccessView(MemeberTaskQuerysetMixin, DetailView):
    template_name = 'memberzone/task_success.html'
    model = MemberTask

    def get_title(self):
        return self.object.success_title


class ProfileEditView(UpdateView):
    model = Profile
    fields = ['first_name', 'last_name', 'street', 'zip', 'place', 'email']
    template_name = 'memberzone/profile_edit.html'
    success_url = reverse_lazy('memberzone:profile_edit_done')

    def get_object(self, queryset=None):
        return self.request.user.profile