# -*-coding:utf-8-*-
# Create your views here.
from django.views.generic import ListView, DetailView, View
from django.views.generic.edit import CreateView, UpdateView

from django.http import HttpResponse, HttpResponseRedirect
from django.contrib import messages
from django.utils import simplejson
from django.core import serializers
from django.core.urlresolvers import reverse
from django.core.exceptions import PermissionDenied
from django.shortcuts import get_object_or_404

from django.contrib.auth.decorators import login_required
from django.utils.decorators import method_decorator

from datetime import datetime
from rest_framework.generics import ListAPIView

from eventos.models import *
from eventos.forms import *
from eventos.serializers import EventoSerializer
from sedes.models import Sede



class AjaxableMixin(object):
    """docstring for AjaxableMixin"""
    def render_to_json_response(self, context, **response_kwargs):
        data = json.dumps(context)
        response_kwargs['content_type'] = 'application/json'
        return HttpResponse(data, **response_kwargs)


class EventoList(AjaxableMixin, ListView):
    """docstring for EventoList"""
    model = Evento

    @method_decorator(login_required)
    def dispatch(self, *args, **kwargs):
        return super(EventoList, self).dispatch(*args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(EventoList, self).get_context_data(**kwargs)
        context['eventos'] = 'active'
        context['eventos_bc'] = 'active'
        return context


class EventoDetail(DetailView):
    """docstring for EventoDetail"""
    model = Evento

    # @method_decorator(login_required)
    def dispatch(self, *args, **kwargs):
        return super(EventoDetail, self).dispatch(*args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(EventoDetail, self).get_context_data(**kwargs)
        context['eventos'] = 'active'
        context['evento_detail_bc'] = 'active'
        return context


class EventoCreate(AjaxableMixin, CreateView):
    """docstring for EventoCreate"""
    model = Evento

    @method_decorator(login_required)
    def dispatch(self, *args, **kwargs):
        return super(EventoCreate, self).dispatch(*args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(EventoCreate, self).get_context_data(**kwargs)
        context['eventos'] = 'active'
        return context

    def form_invalid(self, form):
        response = super(EventoCreate, self).form_invalid(form)
        if self.request.is_ajax():
            return self.render_to_json_response(form.errors, status=400)
        else:
            return response

    def form_valid(self, form):
        response = super(EventoCreate, self).form_valid(form)

        if self.request.is_ajax():
            data = {'pk': self.object.pk}
            return self.render_to_json_response(data)

        messages.success(self.request, 'Evento %s agregado correctamente' % form.instance)
        return response

    def get(self, request, *args, **kwargs):
        initial = {}
        initial['inicio'] = datetime.fromtimestamp(int(request.GET['start']))
        initial['all_day'] = True
        if request.GET['allDay'] != u'true':
            initial['all_day'] = False
            initial['fin'] = initial['inicio']

        if request.GET.get('sede'):
            initial['sede'] = Sede.objects.get(pk = request.GET['sede'])

        self.initial = initial

        return super(EventoCreate, self).get(self, request, *args, **kwargs)


class EventoUpdate(AjaxableMixin, UpdateView):
    """docstring for EventoUpdate"""
    model = Evento

    @method_decorator(login_required)
    def dispatch(self, request, *args, **kwargs):
        return super(EventoUpdate, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(EventoUpdate, self).get_context_data(**kwargs)
        context['eventos'] = 'active'
        return context

    def form_valid(self, form):
        messages.success(self.request, 'Evento %s modificado correctamente' % form.instance)
        return super(EventoUpdate, self).form_valid(form)


class EventoCancelar(View):
    """docstring for EventoCancelar"""
    @method_decorator(login_required)
    def dispatch(self, request, *args, **kwargs):
        return super(EventoCancelar, self).dispatch(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        if not request.user.has_perm('eventos.cancelar_evento'):
            raise PermissionDenied

        evento = get_object_or_404(Evento, pk=request.POST.get('pk'))
        if evento.cancelar():
            data = 'Evento cancelado correctamente.'
            status = 200
        else:
            data = 'El evento ya ha sido cancelado anteriormente'
            status = 500

        return HttpResponse(data, status=status)
        # return HttpResponse('...')


class SolicitanteList(ListView):
    """docstring for SolicitanteList"""
    model = Solicitante

    @method_decorator(login_required)
    def dispatch(self, request, *args, **kwargs):
        return super(SolicitanteList, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(SolicitanteList, self).get_context_data(**kwargs)
        context['solicitantes'] = 'active'
        context['solicitantes_bc'] = 'active'
        return context


class SolicitanteDetail(DetailView):
    """docstring for SolicitanteDetail"""
    model = Solicitante

    @method_decorator(login_required)
    def dispatch(self, request, *args, **kwargs):
        return super(SolicitanteDetail, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(SolicitanteDetail, self).get_context_data(**kwargs)
        context['solicitantes'] = 'active'
        context['solicitante_detail_bc'] = 'active'
        return context


class SolicitanteCreate(CreateView):
    """docstring for SolicitanteCreate"""
    model = Solicitante

    @method_decorator(login_required)
    def dispatch(self, request, *args, **kwargs):
        return super(SolicitanteCreate, self).dispatch(request, *args, **kwargs)

    def form_valid(self, form):
        context = self.get_context_data()
        telefono_form = context['telefono_formset']
        telefono_form
        if telefono_form.is_valid():
            self.object = form.save()
            telefono_form.instance = self.object
            telefono_form.save()
            messages.success(self.request, 'Solicitante %s agregado correctamente' % form.instance)
            return HttpResponseRedirect(self.get_success_url())
        else:
            return self.form_invalid(form)

    def get_context_data(self, **kwargs):
        context = super(SolicitanteCreate, self).get_context_data(**kwargs)

        context['solicitantes'] = 'active'

        if self.request.POST:
            context['telefono_formset'] = TelefonoFormset(self.request.POST)
        else:
            context['telefono_formset'] = TelefonoFormset()

        return context

class SolicitanteUpdate(UpdateView):
    """docstring for SolicitanteUpdate"""
    model = Solicitante

    # @method_decorator(login_required)
    # def dispatch(self, request, *args, **kwargs):
    #     return super(SolicitanteUpdate, self).dispatch(request, *args, **kwargs)

    def form_valid(self, form):
        context = self.get_context_data()
        telefono_form = context['telefono_formset']
        if telefono_form.is_valid():
            self.object = form.save()
            telefono_form.instance = self.object
            telefono_form.save()
            messages.success(self.request, 'Solicitante %s modificado correctamente' % form.instance)
            return HttpResponseRedirect(self.get_success_url())
        else:
            return self.form_invalid(form)

    def get_context_data(self, **kwargs):
        context = super(SolicitanteUpdate, self).get_context_data(**kwargs)

        context['solicitantes'] = 'active'

        if self.request.POST:
            context['telefono_formset'] = TelefonoFormset(self.request.POST, instance=self.object)
        else:
            context['telefono_formset'] = TelefonoFormset(instance=self.object)

        return context


class EventosFeed(View):
    """docstring for EventosFeed"""

    def get(self, request, *args, **kwargs):
        start = request.GET.get('start', 0)
        end = request.GET.get('end', 0)

        eventos = []
        tmp_eventos = Evento.objects.filter(cancelado=False)

        if start:
            start = datetime.fromtimestamp(int(start))
            tmp_eventos = tmp_eventos.filter(inicio__gte=start)

        if end:
            end = datetime.fromtimestamp(int(end))
            tmp_eventos=tmp_eventos.filter(inicio__lte=end)

        if not request.user.is_authenticated():
            tmp_eventos = tmp_eventos.filter(publicado=True, publico=True)

        if hasattr(request.user, 'perfil'):
            tmp_eventos = tmp_eventos.filter(sede=request.user.perfil.sede)

        if request.GET.get('sede'):
            tmp_eventos = tmp_eventos.filter(sede_id=request.GET['sede'])

        for evento in tmp_eventos:
            data = {}
            data['id'] = evento.id
            data['title'] = str(evento)
            data['allDay'] = evento.all_day
            data['color'] = evento.sede.color

            if not evento.publicado:
                data['color'] = 'gray'

            data['url'] = reverse('evento-detail', args=(evento.id,))
            data['start'] = str(evento.inicio)

            if evento.fin:
                data['end'] = str(evento.fin)

            eventos.append(data)

        return HttpResponse(simplejson.dumps(eventos), mimetype='application/json')


class EventoAPIView(ListAPIView):
    serializer_class = EventoSerializer

    def get_queryset(self):
        queryset = Evento.objects.filter(cancelado=False)
        start = self.request.GET.get('start')
        end = self.request.GET.get('end')

        if start:
            start = datetime.fromtimestamp(int(start))
            queryset = queryset.filter(inicio__gte=start)

        if end:
            end = datetime.fromtimestamp(int(end))
            queryset = queryset.filter(inicio__lte=end)

        return queryset