import logging
import os

from django.core.exceptions import SuspiciousOperation
from django.http import HttpResponseRedirect
from django.urls import reverse_lazy
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 EventListView(generic.ListView):
    model = models.Event
    queryset = models.Event.objects.all()


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


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

    def approve(self):
        event = self.get_object()
        event.approved = True
        event.save()

    def get(self, request, *args, **kwargs):
        self.approve()
        return super(EventApproveView, 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()
            self.clean_session_data()
            return HttpResponseRedirect(reverse_lazy('dav_events:home'))

    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)