# -*- encoding:utf-8 -*-
# Create your views here.
import json

from django.contrib import messages
from django.contrib.auth.decorators import login_required, permission_required
from django.contrib.auth.forms import UserCreationForm, SetPasswordForm
from django.contrib.auth.models import User
from django.db.models import Q
from django.http import HttpResponse, HttpResponseRedirect
from django.utils.decorators import method_decorator
from django.views.generic import ListView, DetailView, View
from django.views.generic.base import TemplateView
from django.views.generic.edit import CreateView, UpdateView

from directorio.forms import *
from directorio.models import *


ERROR_MESSAGE = 'Por favor corrija el siguiente error:'


def get_element(adscripcion):
    element = {}

    if adscripcion.adscripcion_set.exists():
        children = []
        for a in adscripcion.adscripcion_set.all():
            ## Aqui está la magia....
            children.append(get_element(a))

        element['children'] = children

    element['id'] = adscripcion.id
    element['label'] = str(adscripcion)
    return element


class AdscripcionFeed(View):
    def get(self, request, *args, **kwargs):
        if request.GET.get('tree'):
            tree = []
            roots = Adscripcion.objects.filter(padre=None)
            for root in roots:
                tree.append(get_element(root))

            return HttpResponse(json.dumps(tree), mimetype='application/json')
        else:
            adscripciones = Adscripcion.objects.all()
            if request.GET.get('term'):
                # return HttpResponse(request.GET.get('term'))
                adscripciones = adscripciones.filter(nombre__icontains=request.GET.get('term'))
            data = []
            for adscripcion in adscripciones:
                data.append({'label': adscripcion.nombre, 'id': adscripcion.id})
            # data = serializers.serialize('json', adscripciones)
            data = json.dumps(data)
            return HttpResponse(data, mimetype='application/json')


class AdscripcionList(TemplateView):
    """docstring for AdscripcionList"""
    template_name = 'directorio/adscripcion_list.html'

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

    def get_context_data(self, **kwargs):
        context = super(AdscripcionList, self).get_context_data(**kwargs)
        context['directorio'] = 'active'
        context['adscripcion_bc'] = 'active'
        return context


class AdscripcionDetail(DetailView):
    """docstring for AdscripcionDetail"""
    model = Adscripcion

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

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


class AdscripcionCreate(CreateView):
    """docstring for AdscripcionCreate"""
    model = Adscripcion
    form_class = AdscripcionForm

    @method_decorator(login_required)
    @method_decorator(permission_required('directorio.add_adscripcion', raise_exception=True))
    def dispatch(self, *args, **kwargs):
        return super(AdscripcionCreate, self).dispatch(*args, **kwargs)

    def render_to_json_response(self, context, **kwargs):
        data = json.dumps(context)
        kwargs['content_type'] = 'application/json'
        return HttpResponse(data, **kwargs)

    def form_valid(self, form):
        # return HttpResponse(form.cleaned_data['hpadre'])
        context = self.get_context_data()
        usuario_form = context['usuario_form']
        if usuario_form.is_valid():
            # usuario_form.instance.first_name = form.instance.nombre[30:]
            if form.cleaned_data['hpadre']:
                form.instance.padre = Adscripcion.objects.get(pk=form.cleaned_data['hpadre'])

            usuario_form.save()
            form.instance.usuario = usuario_form.instance
            self.object = form.save()

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

            messages.success(self.request, 'Adscripción %s agregada correctamente' % form.instance)
            return HttpResponseRedirect(self.get_success_url())
        else:
            return self.form_invalid(form, usuario_form)

    def form_invalid(self, form, usuario_form=None):
        response = super(AdscripcionCreate, self).form_invalid(form)
        if self.request.is_ajax():
            errores = {}
            errores['funcionario'] = form.errors
            if usuario_form:
                errores['usuario'] = usuario_form.errors
            return self.render_to_json_response(errores, status=400)

        messages.error(self.request, ERROR_MESSAGE)
        return response

    def get_context_data(self, **kwargs):
        context = super(AdscripcionCreate, self).get_context_data(**kwargs)
        context['directorio'] = 'active'

        if self.request.POST:
            context['usuario_form'] = UserCreationForm(self.request.POST)
        else:
            context['usuario_form'] = UserCreationForm()

        return context


class AdscripcionUpdate(UpdateView):
    """docstring for AdscripcionUpdate"""
    model = Adscripcion
    form_class = AdscripcionForm

    @method_decorator(login_required)
    @method_decorator(permission_required('directorio.change_adscripcion', raise_exception=True))
    def dispatch(self, *args, **kwargs):
        return super(AdscripcionUpdate, self).dispatch(*args, **kwargs)

    def get(self, request, *args, **kwargs):
        initial = {}
        self.object = self.get_object()
        initial['padre2'] = self.object.padre.nombre if self.object.padre else None
        initial['hpadre'] = self.object.padre.id if self.object.padre else None

        self.initial = initial
        return super(AdscripcionUpdate, self).get(request, *args, **kwargs)

    def form_valid(self, form):
        context = self.get_context_data()
        usuario_form = context['usuario_form']
        if usuario_form.is_valid():
            # usuario_form.instance.first_name = form.instance.nombre
            tmp_usr = User.objects.get(pk=usuario_form.instance.pk)
            usuario_form.instance.is_active = tmp_usr.is_active
            usuario_form.save()
            form.instance.padre = Adscripcion.objects.get(pk=form.cleaned_data['hpadre'])
            self.object = form.save()
            messages.success(self.request, 'Adscripcion %s actualizada correctamente' % self.object)
            return HttpResponseRedirect(self.get_success_url())
        else:
            return self.form_invalid(form)

    def form_invalid(self, form):
        messages.error(self.request, ERROR_MESSAGE)
        return super(AdscripcionUpdate, self).form_invalid(form)

    def get_context_data(self, **kwargs):
        context = super(AdscripcionUpdate, self).get_context_data(**kwargs)
        context['directorio'] = 'active'

        if self.request.POST:
            context['usuario_form'] = UsuarioForm(self.request.POST, instance=self.object.usuario)
        else:
            context['usuario_form'] = UsuarioForm(instance=self.object.usuario)

        return context


class FuncionarioList(ListView):
    """docstring for FuncionarioList"""
    model = Funcionario

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

    def get_context_data(self, **kwargs):
        context = super(FuncionarioList, self).get_context_data(**kwargs)
        context['directorio'] = 'active'
        context['funcionario_bc'] = 'active'

        return context


class FuncionarioDetail(DetailView):
    """docstring for FuncionarioDetail"""
    model = Funcionario

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

    def get_context_data(self, **kwargs):
        context = super(FuncionarioDetail, self).get_context_data(**kwargs)
        context['directorio'] = 'active'

        return context


class FuncionarioCreate(CreateView):
    """docstring for FuncionarioCreate"""
    model = Funcionario
    form_class = FuncionarioForm

    @method_decorator(login_required)
    @method_decorator(permission_required('directorio.add_funcionario', raise_exception=True))
    def dispatch(self, *args, **kwargs):
        return super(FuncionarioCreate, self).dispatch(*args, **kwargs)

    def form_valid(self, form):
        context = self.get_context_data()
        usuario_form = context['usuario_form']
        correo_form = context['correo_form']
        if usuario_form.is_valid() and correo_form.is_valid():
            usuario = usuario_form.save()
            usuario.email = correo_form.cleaned_data['correo']
            usuario.save()
            form.instance.adscripcion = Adscripcion.objects.get(pk=form.cleaned_data['hadscripcion'])
            form.instance.usuario = usuario_form.instance
            self.object = form.save()
            messages.success(self.request, 'Funcionario %s agregado correctamente' % self.object)
            return HttpResponseRedirect(self.get_success_url())
        else:
            return self.form_invalid(form)

    def form_invalid(self, form):
        messages.error(self.request, ERROR_MESSAGE)
        return super(FuncionarioCreate, self).form_invalid(form)

    def get_context_data(self, **kwargs):
        context = super(FuncionarioCreate, self).get_context_data(**kwargs)
        context['directorio'] = 'active'

        if self.request.POST:
            context['usuario_form'] = UserCreationForm(self.request.POST)
            context['correo_form'] = CorreoForm(self.request.POST)
        else:
            context['usuario_form'] = UserCreationForm()
            context['correo_form'] = CorreoForm()

        return context


class FuncionarioUpdate(UpdateView):
    """docstring for FuncionarioUpdate"""
    model = Funcionario
    form_class = FuncionarioForm

    @method_decorator(login_required)
    @method_decorator(permission_required('directorio.change_funcionario', raise_exception=True))
    def dispatch(self, *args, **kwargs):
        return super(FuncionarioUpdate, self).dispatch(*args, **kwargs)

    def get(self, request, *args, **kwargs):
        initial = {}
        self.object = self.get_object()
        initial['adscripcion2'] = self.object.adscripcion.nombre
        initial['hadscripcion'] = self.object.adscripcion.id

        self.initial = initial
        return super(FuncionarioUpdate, self).get(request, *args, **kwargs)

    def form_valid(self, form):
        context = self.get_context_data()
        usuario_form = context['usuario_form']
        correo_form = context['correo_form']
        if usuario_form.is_valid() and correo_form.is_valid():
            tmp_usr = User.objects.get(pk=usuario_form.instance.pk)
            usuario_form.instance.is_active = tmp_usr.is_active
            usuario = usuario_form.save()
            usuario.email = correo_form.cleaned_data['correo']
            usuario.save()
            form.instance.adscripcion = Adscripcion.objects.get(pk=form.cleaned_data['hadscripcion'])
            self.object = form.save()
            messages.success(self.request, 'Funcionario %s actualizado correctamente' % self.object)
            return HttpResponseRedirect(self.get_success_url())
        else:
            return self.form_invalid(form)

    def form_invalid(self, form):
        messages.error(self.request, ERROR_MESSAGE)
        return super(FuncionarioUpdate, self).form_invalid(form)

    def get_context_data(self, **kwargs):
        context = super(FuncionarioUpdate, self).get_context_data(**kwargs)
        context['directorio'] = 'active'
        correo_form = CorreoForm(initial={'correo': self.object.usuario.email})

        if self.request.POST:
            context['usuario_form'] = UsuarioForm(self.request.POST, instance=self.object.usuario)
            context['correo_form'] = CorreoForm(self.request.POST)

        else:
            context['usuario_form'] = UsuarioForm(instance=self.object.usuario)
            context['correo_form'] = correo_form

        return context


class EmpresaList(ListView):
    """docstring for Empresa"""
    model = Empresa

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

    def get_context_data(self, **kwargs):
        context = super(EmpresaList, self).get_context_data(**kwargs)
        context['directorio'] = 'active'
        context['empresa_bc'] = 'active'

        return context


class EmpresaDetail(DetailView):
    model = Empresa

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

    def get_context_data(self, **kwargs):
        context = super(EmpresaDetail, self).get_context_data(**kwargs)
        context['directorio'] = 'active'

        return context


class EmpresaCreate(CreateView):
    """docstring for EmpresaCreate"""
    model = Empresa
    form_class = EmpresaForm

    @method_decorator(login_required)
    @method_decorator(permission_required('directorio.add_empresa', raise_exception=True))
    def dispatch(self, *args, **kwargs):
        return super(EmpresaCreate, self).dispatch(*args, **kwargs)

    def form_valid(self, form):
        context = self.get_context_data()
        usuario_form = context['usuario_form']

        correo_form = context['correo_form']
        if usuario_form.is_valid() and correo_form.is_valid():
            usuario = usuario_form.save()
            usuario.email = correo_form.cleaned_data['correo']
            usuario.save()
            form.instance.usuario = usuario_form.instance
            self.object = form.save()
            messages.success(self.request, 'Empresa %s agregada correctamente' % self.object)
            return HttpResponseRedirect(self.get_success_url())
        else:
            return self.form_invalid(form)

    def form_invalid(self, form):
        messages.error(self.request, ERROR_MESSAGE)
        return super(EmpresaCreate, self).form_invalid(form)

    def get_context_data(self, **kwargs):
        context = super(EmpresaCreate, self).get_context_data(**kwargs)
        context['directorio'] = 'active'

        if self.request.POST:
            context['usuario_form'] = UserCreationForm(self.request.POST)
            context['correo_form'] = CorreoForm(self.request.POST)
        else:
            context['usuario_form'] = UserCreationForm()
            context['correo_form'] = CorreoForm()

        return context


class EmpresaUpdate(UpdateView):
    """docstring for EmpresaUpdate"""
    model = Empresa
    form_class = EmpresaForm

    @method_decorator(login_required)
    @method_decorator(permission_required('directorio.change_empresa', raise_exception=True))
    def dispatch(self, *args, **kwargs):
        return super(EmpresaUpdate, self).dispatch(*args, **kwargs)

    def form_valid(self, form):
        context = self.get_context_data()
        usuario_form = context['usuario_form']
        correo_form = context['correo_form']
        if usuario_form.is_valid() and correo_form.is_valid():
            tmp_usr = User.objects.get(pk=usuario_form.instance.pk)
            usuario_form.instance.is_active = tmp_usr.is_active
            usuario = usuario_form.save()
            usuario.email = correo_form.cleaned_data['correo']
            usuario.save()
            self.object = form.save()
            messages.success(self.request, 'Empresa %s actualizada correctamente' % self.object)
            return HttpResponseRedirect(self.get_success_url())
        else:
            return self.form_invalid(form)

    def form_invalid(self, form):
        messages.error(self.request, ERROR_MESSAGE)
        return super(EmpresaUpdate, self).form_invalid(form)

    def get_context_data(self, **kwargs):
        context = super(EmpresaUpdate, self).get_context_data(**kwargs)
        context['directorio'] = 'active'
        correo_form = CorreoForm(initial={'correo': self.object.usuario.email})

        if self.request.POST:
            context['usuario_form'] = UsuarioForm(self.request.POST, instance=self.object.usuario)
            context['correo_form'] = CorreoForm(self.request.POST)
        else:
            context['usuario_form'] = UsuarioForm(instance=self.object.usuario)
            context['correo_form'] = correo_form
        return context


class PersonaList(ListView):
    """docstring for PersonaList"""
    model = PersonaFisica

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

    def get_context_data(self, **kwargs):
        context = super(PersonaList, self).get_context_data(**kwargs)
        context['directorio'] = 'active'
        context['persona_bc'] = 'active'

        return context


class PersonaDetail(DetailView):
    """docstring for PersonaDetail"""
    model = PersonaFisica

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

    def get_context_data(self, **kwargs):
        context = super(PersonaDetail, self).get_context_data(**kwargs)
        context['directorio'] = 'active'

        return context


class PersonaCreate(CreateView):
    """docstring for PersonaCreate"""
    model = PersonaFisica
    form_class = PersonaForm

    @method_decorator(login_required)
    @method_decorator(permission_required('directorio.add_personafisica', raise_exception=True))
    def dispatch(self, *args, **kwargs):
        return super(PersonaCreate, self).dispatch(*args, **kwargs)

    def form_valid(self, form):
        context = self.get_context_data()
        usuario_form = context['usuario_form']
        correo_form = context['correo_form']
        if usuario_form.is_valid() and correo_form.is_valid():
            usuario = usuario_form.save()
            usuario.email = correo_form.cleaned_data['correo']
            usuario.save()
            form.instance.usuario = usuario_form.instance
            self.object = form.save()
            messages.success(self.request, 'Persona %s agregada correctamente' % self.object)
            return HttpResponseRedirect(self.get_success_url())
        else:
            return self.form_invalid(form)

    def form_invalid(self, form):
        messages.error(self.request, ERROR_MESSAGE)
        return super(PersonaCreate, self).form_invalid(form)

    def get_context_data(self, **kwargs):
        context = super(PersonaCreate, self).get_context_data(**kwargs)
        context['directorio'] = 'active'

        if self.request.POST:
            context['usuario_form'] = UserCreationForm(self.request.POST)
            context['correo_form'] = CorreoForm(self.request.POST)
        else:
            context['usuario_form'] = UserCreationForm()
            context['correo_form'] = CorreoForm()

        return context


class PersonaUpdate(UpdateView):
    """docstring for PersonaUpdate"""
    model = PersonaFisica
    form_class = PersonaForm

    @method_decorator(login_required)
    @method_decorator(permission_required('directorio.change_personafisica', raise_exception=True))
    def dispatch(self, *args, **kwargs):
        return super(PersonaUpdate, self).dispatch(*args, **kwargs)

    def form_valid(self, form):
        context = self.get_context_data()
        usuario_form = context['usuario_form']
        correo_form = context['correo_form']
        if usuario_form.is_valid() and correo_form.is_valid():
            tmp_usr = User.objects.get(pk=usuario_form.instance.pk)
            usuario_form.instance.is_active = tmp_usr.is_active
            usuario = usuario_form.save()
            usuario.email = correo_form.cleaned_data['correo']
            usuario.save()
            form.instance.usuario = usuario_form.instance
            self.object = form.save()
            messages.success(self.request, 'Persona %s actualizada correctamente' % self.object)
            return HttpResponseRedirect(self.get_success_url())
        else:
            return self.form_invalid(form)

    def form_invalid(self, form):
        messages.error(self.request, ERROR_MESSAGE)
        return super(PersonaUpdate, self).form_invalid(form)

    def get_context_data(self, **kwargs):
        context = super(PersonaUpdate, self).get_context_data(**kwargs)
        context['directorio'] = 'active'
        correo_form = CorreoForm(initial={'correo': self.object.usuario.email})

        if self.request.POST:
            context['usuario_form'] = UsuarioForm(self.request.POST, instance=self.object.usuario)
            context['correo_form'] = CorreoForm(self.request.POST)
        else:
            context['usuario_form'] = UsuarioForm(instance=self.object.usuario)
            context['correo_form'] = correo_form

        return context


class PasswdChange(UpdateView):
    """docstring for PasswdChange"""
    model = User
    template_name = 'directorio/passwd_change.html'
    form_class = SetPasswordForm
    context_object_name = 'usuario'

    def get_form(self, form_class):
        form_kwargs = self.get_form_kwargs()
        form_kwargs['user'] = self.object
        return form_class(form_kwargs)

    def form_invalid(self, form):
        messages.error(self.request, ERROR_MESSAGE)
        return super(PasswdChange, self).form_invalid(form)


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

    def get(self, request, *args, **kwargs):
        resultado = []

        adscripciones = Adscripcion.objects.all()
        funcionarios = Funcionario.objects.all()
        empresas = Empresa.objects.all()
        personas = PersonaFisica.objects.all()

        if request.GET.get('term'):
            term = request.GET.get('term')
            adscripciones = adscripciones.filter(nombre__icontains=term)
            empresas = empresas.filter(nombre__icontains=term)

            funcionarios = funcionarios.filter(
                Q(nombre__icontains=term) |
                Q(apellido_paterno__icontains=term) |
                Q(apellido_materno__icontains=term)
            )

            personas = personas.filter(
                Q(nombre__icontains=term) |
                Q(apellido_paterno__icontains=term) |
                Q(apellido_materno__icontains=term)
            )

        # recolectar adscripciones
        for adscripcion in adscripciones:
            resultado.append({"label": adscripcion.nombre, "id": adscripcion.usuario.username})

        # recolectar funcionarios
        for funcionario in funcionarios:
            resultado.append({"label": r'%s (%s)' % (str(funcionario), str(funcionario.adscripcion)), "id": funcionario.usuario.username})

        # recolectar empresas
        for empresa in empresas:
            resultado.append({"label": empresa.nombre, "id": empresa.usuario.username})

        # recolectar personas
        for persona in personas:
            nombre = None
            if persona.empresa:
                nombre = r'%s (%s)' % (str(persona), str(persona.empresa))
            else:
                nombre = r'%s' % str(persona)

            resultado.append({"label": nombre, "id": persona.usuario.username})

        return HttpResponse(json.dumps(resultado), mimetype="application/json")