import logging
import os

from django.contrib.auth import login, views as auth_views
from django.contrib.auth.decorators import login_required
from django.core.exceptions import SuspiciousOperation
from django.http import HttpResponseRedirect
from django.urls import reverse, reverse_lazy
from django.utils.decorators import method_decorator
from django.views import generic

from . import forms
from . import models

logger = logging.getLogger(__name__)


class HomeView(generic.TemplateView):
    template_name = 'dav_events/home.html'


class ImprintView(generic.TemplateView):
    template_name = 'dav_events/imprint.html'


class LoginView(auth_views.LoginView):
    form_class = forms.LoginForm
    next_page = reverse_lazy('dav_events:event_list')
    template_name = 'dav_events/auth/login_form.html'

    def get_success_url(self):
        url = self.get_redirect_url()
        return url or self.next_page


class LogoutView(auth_views.LogoutView):
    next_page = reverse_lazy('dav_events:home')


class SetPasswordView(auth_views.PasswordChangeView):
    form_class = forms.SetPasswordForm
    template_name = 'dav_events/auth/set_password_form.html'
    success_url = reverse_lazy('dav_events:event_list')


class EventListView(generic.ListView):
    model = models.Event
    queryset = models.Event.objects.all()


class EventDetailView(generic.DetailView):
    model = models.Event


class EventAcceptView(generic.DetailView):
    model = models.Event

    def accept(self):
        event = self.get_object()
        event.accept()

    def get(self, request, *args, **kwargs):
        self.accept()
        return super(EventAcceptView, self).get(request, *args, **kwargs)


class EventCreateView(generic.FormView):
    initial_form_class = forms.ModeForm
    template_dir = os.path.join('dav_events', 'event_create')
    default_template_name = 'default.html'
    abort_url = reverse_lazy('dav_events:home')

    def get_template_names(self):
        form = self.get_form()
        form_name = form.form_name
        template = os.path.join(self.template_dir, '{}.html'.format(form_name))
        default_template = os.path.join(self.template_dir, self.default_template_name)
        return [
            template, default_template
        ]

    def get_form_class(self, form_name=None):
        if form_name is not None:
            form_class = getattr(forms, form_name)
        elif 'dav_events_event_create_next_form_name' in self.request.session:
            form_name = self.request.session['dav_events_event_create_next_form_name']
            form_class = getattr(forms, form_name)
            if not issubclass(form_class, forms.ChainedForm):
                raise SuspiciousOperation('Invalid next form: {}'.format(form_name))
        else:
            form_class = self.initial_form_class

        return form_class

    def get_context_data(self, **kwargs):
        context = super(EventCreateView, self).get_context_data(**kwargs)
        context['abort_url'] = self.abort_url
        return context

    def form_valid(self, form):
        form.add_session_data(self.request.session.get('dav_events_event_create_previous_data', dict()))
        event = form.save()

        next_form_name = form.next_form_name
        if next_form_name:
            self.request.session['dav_events_event_create_previous_data'] = form.get_session_data()
            self.request.session['dav_events_event_create_next_form_name'] = next_form_name
            next_form_class = self.get_form_class(next_form_name)
            next_form = next_form_class(session_data=form.get_session_data())
            return self.render_to_response(self.get_context_data(form=next_form, event=event))
        else:
            event.save()
            owner = event.owner
            self.clean_session_data()
            if self.request.user.is_authenticated:
                next_url = reverse('dav_events:event_list')
            elif owner.has_usable_password():
                next_url = reverse('dav_events:event_list')
            else:
                login(self.request, owner)
                next_url = reverse('dav_events:set_password', kwargs={'pk': owner.pk})
            return HttpResponseRedirect(next_url)

    def clean_session_data(self, session=None):
        if session is None:
            session = self.request.session
        if 'dav_events_event_create_next_form_name' in session:
            del session['dav_events_event_create_next_form_name']
        if 'dav_events_event_create_previous_data' in session:
            del session['dav_events_event_create_previous_data']

    def get(self, request, *args, **kwargs):
        self.clean_session_data(request.session)
        return super(EventCreateView, self).get(request, *args, **kwargs)