# -*- coding: utf-8 -*-
from django.core.exceptions import ObjectDoesNotExist
from django.core.urlresolvers import reverse, reverse_lazy
from django.db.models import Q
from django.http import Http404
from django.http import HttpResponseForbidden
from django.http import HttpResponseNotFound
from django.http import HttpResponsePermanentRedirect
from django.views.generic.edit import FormMixin, FormView
from django.conf import settings
from django.template.loader import render_to_string
from django.template import RequestContext
from django.utils.translation import ugettext_lazy as _

from haystack.query import SearchQuerySet

from emencia.django.newsletter.forms import ContactForm
from emencia.django.newsletter.models import Contact
from functions.custom_views import ContextMixin
from functions.custom_views import ReverseOrderMixin
from functions.custom_views import ListView
from functions.http import JsonResponse

from exposition.models import Exposition
from conference.models import Conference

from .forms import FilterForm


class FilterListView_(ContextMixin, FormMixin, ListView):
    initial_ctx = {'filtering': True}
    form_class = FilterForm
    paginate_by = settings.CLIENT_PAGINATION
    template_name = 'events/filter_listview.html'
    _ajax_results_template_name = 'events/filter_listview_ajax.html'
    _ajax_form_template_name = 'includes/events/filter_form.html'

    def get_form_kwargs(self):
        kwargs = super(FilterListView_, self).get_form_kwargs()
        kwargs.update({'data': self.request.GET})
        return kwargs

    def get_queryset(self):
        if self.form.is_valid():
            qs = self.form.filter()
            # import pdb; pdb.set_trace()
        else:
            qs = self.form.default_filter()
        if self.kwargs.get('with_form', True):
            self.form.recalculate_choices()
        # print(self.form.data, self.form.cleaned_data, self.form.get_date_begin_periods())
        # import pdb; pdb.set_trace()
        return qs

    def get(self, request, *args, **kwargs):
        self.form = self.get_form(self.get_form_class())
        self.extra_ctx['form'] = self.form

        # ajax
        if request.is_ajax():
            ctx = RequestContext(request, self.get_context_data(object_list=self.get_queryset()))
            data = {'success': True}
            if kwargs.get('with_results', True):
                data.update({
                    'results': render_to_string(self._ajax_results_template_name, ctx),
                })
            if kwargs.get('with_form', True):
                data.update({
                    'form': render_to_string(self._ajax_form_template_name, ctx),
                    })

            return JsonResponse(data)
        # usual get
        return super(FilterListView_, self).get(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        return self.get(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(FilterListView_, self).get_context_data(**kwargs)
        # get params for paginator
        get = self.form.data.copy()
        if 'page' in get:
            del get['page']
        context['GETparams'] = get.urlencode() if hasattr(get, 'urlencode') else ''

        return context

class FilterListView(ReverseOrderMixin, FilterListView_):
    pass


class SubscribeView(FormView):
    form_class = ContactForm
    template_name = None
    redirect_url = reverse_lazy('subscription_activation_send')
    models = {'expo': (Exposition, 'expositions'), 'conf': (Conference, 'conferences')}
    defaults = {
        # 'activated': True,
        # 'from_events': True,
        'dailymailing': False,
    }

    def get_event(self):
        model, self.attr = self.models.get(self.kwargs.get('model'))
        slug = self.kwargs.get('slug')
        return model.objects.get(url=slug)

    def set_event(self):
        attr = getattr(self.contact, self.attr)
        attr.add(self.event)

    def get_contact(self):
        user = self.request.user
        defaults = {
            'first_name': user.first_name,
            'last_name': user.last_name,
            'email': user.email,
            'user': user,
        }
        defaults.update(self.defaults)
        try:
            contact = Contact.objects.filter(Q(user=user) | Q(email=user.email))[0]
        except (Contact.DoesNotExist, IndexError):
            contact = Contact(defaults)
            contact.save()
        return contact

    def get_form_kwargs(self):
        """
        Returns the keyword arguments for instantiating the form.
        """
        kwargs = super(SubscribeView, self).get_form_kwargs()
        # kwargs.update({'instance': self.object})
        return kwargs

    def dispatch(self, request, *args, **kwargs):
        if not request.is_ajax():
            return HttpResponseForbidden()
        self.attr = None
        self.contact = None
        try:
            self.event = self.get_event()
        except ObjectDoesNotExist:
            return HttpResponseNotFound()
        self._redirect_url = self.event.get_absolute_url()
        return super(SubscribeView, self).dispatch(request, *args, **kwargs)

    def form_invalid(self, form):
        return JsonResponse({'errors': form.errors})

    def form_valid(self, form):
        contact = form.save(commit=False)
        if not contact.pk:
            contact.dailymailing = False
            contact.save()
            contact.send_activation()
            self._redirect_url = self.redirect_url
        self.contact = contact
        return self.success_responce(sent=True)

    def success_responce(self, sent=False):
        self.set_event()
        return JsonResponse({'success': True, 'sent': sent, 'redirect_url': str(self._redirect_url)})

    def post(self, request, *args, **kwargs):
        if request.user.is_authenticated():
            self.contact = self.get_contact()
            return self.success_responce()
        return super(SubscribeView, self).post(request, *args, **kwargs)


def event_visit(request, event_type, id):
    args = {'success': False}
    user = request.user
    model = {'exposition': Exposition, 'conference': Conference}.get(event_type)
    if user.is_authenticated():
        event = model.objects.safe_get(id=id)
        if user in event.users.all():
            event.users.remove(user)
            args['in'] = False
        else:
            event.users.add(user)
            args['in'] = True

        args['success'] = True
    else:
        args['not_authorized'] = True
        args['success'] = True
    return JsonResponse(args)