# -*- coding: utf-8 -*-

from django.shortcuts import render_to_response
from django.template import RequestContext
from django.views.generic.simple import direct_to_template
from django.http import Http404,HttpResponseRedirect,HttpResponse
from django.conf import settings
from django.contrib.auth.decorators import login_required
from django.core.urlresolvers import reverse
from django.utils import simplejson
from django.core.exceptions import PermissionDenied

from cuestionario.tasks import cuestionarios

from app.deco import role_required,owner_required
from app.views import get_info

@login_required
@role_required(role='profesor')
def index(request,slug):
    from cuestionario.models import Cuestionario,Pregunta
    from tarea.models import Asignatura

    profile = request.user.get_profile()
    k_info = get_info(request,profile,slug)

    asignatura = Asignatura.objects.get(slug__iexact = slug)
    cuestionario = Cuestionario.objects.filter(autor=profile.user,actividad__asignatura__slug=slug)
    preguntas = Pregunta.objects.filter(cuestionario=cuestionario,realizador=None)

    return render_to_response('cuestionario/%s/indice.html'% profile.user.usuario.rol,{'cuestionarios':cuestionario,'preguntas':preguntas,'informacion':k_info},context_instance = RequestContext(request))


@login_required
def evaluar(request,slug):
    from cuestionario.models import Evaluacion
    import datetime

    profile = request.user.get_profile()
    k_info = get_info(request,profile,slug)

    evaluacion = Evaluacion.objects.filter(user=profile.user,tarea__realizado=True,tarea__actividades__asignatura__slug__iexact=slug,tarea__actividades__cuestionario_actividad__enddate__gte=datetime.date.today(),tarea__actividades__hide=True)

    return render_to_response('cuestionario/%s/evaluacion.html'% profile.user.usuario.rol,{'evaluaciones':evaluacion,'informacion':k_info},context_instance = RequestContext(request))

@login_required
def ver_evaluaciones_de_alumno(request,slug,alumno):
    from cuestionario.models import Evaluacion

    profile = request.user.get_profile()
    k_info = get_info(request,profile,slug)

    evaluacion = Evaluacion.objects.filter(user=profile.user,tarea__actividades__asignatura__slug__iexact=slug,realizado=True,tarea__actividades__hide=True)

    return render_to_response('cuestionario/%s/ver_evaluaciones_alumno.html'% profile.user.usuario.rol,{'evaluacion':evaluacion,'informacion':k_info},context_instance = RequestContext(request))

@login_required
@role_required(role='profesor')
#@owner_required(model='Evaluacion')
def ver_correciones_actividad(request,slug,id,alumno):
    from cuestionario.models import Evaluacion
    from tarea.models import Actividad

    profile = request.user.get_profile()
    k_info = get_info(request,profile,slug)

    evaluaciones = Evaluacion.objects.filter(tarea__actividades__asignatura__slug__iexact=slug,tarea__id__iexact=id,realizado=True,tarea__actividades__hide=True)

    if evaluaciones:
        actividad = evaluaciones[0].tarea.actividades
    else:
        actividad = Actividad.objects.get(tarea_tarea_actividades__id=id)

    return render_to_response('formwizard/%s/tarea/view/tarea.html'% request.user.usuario.rol,{'evaluaciones':evaluaciones,'actividad':actividad,'informacion':k_info,'alumno':alumno},context_instance = RequestContext(request))

@login_required
def evaluar_tarea(request,slug,id):
    from cuestionario.models import Evaluacion,Pregunta
    from tarea.models import Tarea,Pregunta as PreguntaActividad

    profile = request.user.get_profile()
    k_info = get_info(request,profile,slug)

    try:
        evaluacion = Evaluacion.objects.get(user=profile.user,tarea__actividades__id=id,realizado=False,tarea__actividades__hide=True)
        tarea = Tarea.objects.get(actividades__id=evaluacion.tarea.actividades.id,actividades__asignatura__slug__iexact=slug,realizado=True,user__username=evaluacion.tarea.user)
        preguntas_tarea = PreguntaActividad.objects.filter(pregunta_evaluada=None,actividad=evaluacion.tarea.actividades.id,realizador=tarea.user)
        preguntas_actividad = PreguntaActividad.objects.exclude(pregunta_evaluada=None,pregunta_evaluada__realizador=None).filter(realizador=None,actividad__asignatura__slug__iexact=slug,actividad__id__iexact=tarea.actividades.id)

        if evaluacion:
            preguntas = Pregunta.objects.filter(realizador=None,cuestionario__id=evaluacion.cuestionario.id,cuestionario__actividad__asignatura__slug=slug)
        
            if request.method=='POST':
                respuesta = None

                # Guardamos las respuestas
                respuestas = dict(request.POST)
                
                # Califica pregunta
                for c in range(preguntas_actividad.count()):
                    if 'califica['+ str(c+1) +']' in respuestas.keys():
                        calificacion =  request.POST['califica['+ str(c+1) +']']
                        if 'nota['+ str(c+1) +']' in respuestas.keys() and 'comentario['+ str(c+1) +']' in respuestas.keys() :
                            comentario = request.POST['nota['+ str(c+1) +']']
                            comentario_alumno = request.POST['comentario['+ str(c+1) +']']
                            calificar_actividad_pregunta(profile,slug,int(c+1),evaluacion.tarea.actividades.id,evaluacion.tarea.user,calificacion,comentario,comentario_alumno)
                        elif 'nota['+ str(c+1) +']' in respuestas.keys() and not 'comentario['+ str(c+1) +']' in respuestas.keys():
                            comentario = request.POST['nota['+ str(c+1) +']']
                            calificar_actividad_pregunta(profile,slug,int(c+1),evaluacion.tarea.actividades.id,evaluacion.tarea.user,calificacion,comentario)
                        
                        elif 'comentario['+ str(c+1) +']' in respuestas.keys():
                            comentario_alumno = request.POST['comentario['+ str(c+1) +']']
                            calificar_actividad_pregunta(profile,slug,int(c+1),evaluacion.tarea.actividades.id,evaluacion.tarea.user,calificacion,comentario_alumno=comentario_alumno)

                        else:
                            calificar_actividad_pregunta(profile,slug,int(c+1),evaluacion.tarea.actividades.id,evaluacion.tarea.user,calificacion)


                for i in range(preguntas.count()):
                    if preguntas[i].type != 3 and 'hash['+ str(i+1) +']' in respuestas.keys():
                        respuesta = request.POST['hash['+ str(i+1) +']']
                        realizar_cuestionario_pregunta(profile,slug,int(i+1),evaluacion.cuestionario.id,respuesta)


                    elif preguntas[i].type == 3:
                        elecciones = preguntas[i].eleccion_pregunta.all()

                        for x in range(elecciones.count()):
                            if 'hash['+ str(i+1) +'-'+ str(elecciones[x].nr) +']' in respuestas.keys():
                                respuesta = request.POST['hash['+ str(i+1) +'-'+ str(elecciones[x].nr) +']']
                                realizar_cuestionario_pregunta(profile,slug,int(i+1),evaluacion.cuestionario.id,respuesta)

                    else:
                        respuesta = None
                        realizar_cuestionario_pregunta(profile,slug,int(i+1),evaluacion.cuestionario.id,respuesta)

                ## Normal mode
                evaluacion.realizado = True
                from decimal import *
                evaluacion.nota = Decimal.from_float(puntuar_evaluacion(request,slug,evaluacion.id))
                tarea = evaluacion.tarea
                if evaluacion.tarea.nota:
                    tarea.nota = Decimal.from_float(float(float(tarea.nota)+float(evaluacion.nota))/2.0)
                else:
                    tarea.nota = Decimal(str(puntuar_evaluacion(request,slug,evaluacion.id)))
                tarea.save()
                evaluacion.save()
                return HttpResponseRedirect(reverse('app.views.ver_asignatura',args=[slug]))

                ## Debug mode 
                #message = simplejson.dumps(request.POST, sort_keys=True, indent=5)
                #return HttpResponse(message, mimetype="application/json")

            else:
                return render_to_response('cuestionario/%s/evaluar_tarea.html'% profile.user.usuario.rol,{'evaluacion':evaluacion,'tarea':tarea,'preguntas':preguntas,'preguntas_actividad':preguntas_actividad,'preguntas_tarea':preguntas_tarea,'informacion':k_info},context_instance = RequestContext(request))

        """Tarea corregida"""
    except Evaluacion.DoesNotExist:
        raise PermissionDenied
    
    except Tarea.DoesNotExist:
        raise PermissionDenied

    return render_to_response('cuestionario/%s/evaluar_tarea.html'% profile.user.usuario.rol,{'evaluacion':evaluacion,'informacion':k_info},context_instance = RequestContext(request))

def realizar_cuestionario_pregunta(profile,asignatura,nr,cuestionario,respuesta):
    from cuestionario.models import Pregunta

    try:
        query = Pregunta.objects.filter(nr__iexact=nr,cuestionario=cuestionario).order_by('id')[0]
        pregunta = Pregunta.objects.get(nr__iexact=nr,realizador=profile.user)
    
        if pregunta.type == 3:
            crear_cuestionario_respuesta(profile,asignatura,pregunta,cuestionario,respuesta)
    
    except Pregunta.DoesNotExist:
        query = Pregunta.objects.filter(nr__iexact=nr,cuestionario=cuestionario).order_by('id')[0]

        # Salva la pregunta usuario de la tarea
        pregunta = Pregunta(realizador=profile.user,nr=query.nr,text=query.text,type=query.type,cuestionario=query.cuestionario,val=query.val)
        pregunta.save()

        # Crea la respuesta relacionada con dicha pregunta
        crear_cuestionario_respuesta(profile,asignatura,pregunta,cuestionario,respuesta)

def crear_cuestionario_respuesta(profile,asignatura,pregunta,cuestionario,respuesta):
        from cuestionario.models import Respuesta,Eleccion
    
        if pregunta.type == 1:
            respuesta_obj = Respuesta(pregunta=pregunta,respuesta=respuesta)
            respuesta_obj.save()
    
        elif pregunta.type == 2 or pregunta.type == 3 or pregunta.type == 4 or pregunta.type == 5:
            try:
                eleccion = Eleccion.objects.get(pregunta__nr=pregunta.nr,name=respuesta,pregunta__realizador=None)
                eleccion_obj = Eleccion(pregunta=pregunta,nr=eleccion.nr,name=eleccion.name,correct=eleccion.correct,val=eleccion.val)
                eleccion_obj.save()
                
            except Eleccion.DoesNotExist:
                raise PermissionDenied

        else:
            return HttpResponse(pregunta.type, mimetype="application/json")

def calificar_actividad_pregunta(profile,slug,pregunta,actividad,alumno,calificacion,comentario=None,comentario_alumno=None):
    from tarea.models import Pregunta,Eleccion

    pr = Pregunta.objects.get(nr=pregunta,pregunta_evaluada=None,actividad__id__iexact=actividad,realizador=alumno)
    query = Pregunta.objects.filter(nr=pregunta,realizador=None,actividad__asignatura__slug__iexact=slug,actividad__id__iexact=actividad).order_by('id')
    pregunta_evaluada = query[0]


    # Creo pregunta respondida por el usuario
    pregunta = Pregunta(realizador=profile.user,nr=pregunta_evaluada.nr,type=pregunta_evaluada.type,text=pregunta_evaluada.text,actividad=query[0].actividad,val=pregunta_evaluada.val)

    # Si existe algun comentario lo añadimos
    if comentario:
        pregunta.comentario = comentario

    if comentario_alumno:
        pregunta.comentario_alumno = comentario_alumno

    pregunta.save()

    # Añadimos la calificacion que ha dado a la pregunta creada anteriormente
    eleccion = Eleccion(pregunta=pregunta,nr=calificacion,name=calificacion,correct=True,val=calificacion)
    eleccion.save()

    # Añadimos la pregunta calificada a la pregunta que queremos puntuar
    pr.tarea_pregunta_evaluada_actividad.add(pregunta)
    pr.save()


def puntuar_evaluacion(request,slug,evaluacion):
    #from cuestionario.models import Cuestionario,Pregunta
    from tarea.models import Actividad,Pregunta
    from cuestionario.models import Evaluacion

    profile = request.user.get_profile()
    k_info = get_info(request,profile,slug)

    evaluacion = Evaluacion.objects.get(id=evaluacion)
    query = Pregunta.objects.filter(realizador=profile.user,actividad=evaluacion.tarea.actividades,actividad__asignatura__slug=slug).exclude(pregunta_evaluada=None)
    preguntas = Pregunta.objects.filter(realizador=None,actividad=evaluacion.tarea.actividades,actividad__asignatura__slug=slug,pregunta_evaluada=None)

    nota_general = 0.0
    nota_alumno = 0.0

    """ Valor total de las preguntas"""
    for p in preguntas.all():
        nota_general += float(p.val)

    print "Nota general %s" % nota_general

    """ Valor de cada eleccion"""
    for nota in query.all():
        for eleccion in nota.tarea_eleccion_pregunta.all():
            print "Valor  %s\t %s" % (nota.pregunta_evaluada.val,eleccion.val)
            nota_alumno += float((nota.pregunta_evaluada.val/10.0) * eleccion.val)
            print "nota_alumno %s\n" % nota_alumno 

    print "nota_alumno %s\n" % nota_alumno 
    nota_final = float((nota_alumno*10)/float(nota_general))
    print "nota_final %s\n" % nota_final
    return float(nota_final)


@login_required
def ver_alumno_asignatura(request,slug,actividad,alumno):
    from cuestionario.models import Cuestionario,Pregunta
    
    profile = request.user.get_profile()
    k_info = get_info(request,profile,slug)
    
    try:
        cuestionario = Cuestionario.objects.get(actividad=id,actividad__asignatura__slug=slug,hide=True)
        if profile.user.usuario.rol == 'profesor':
            preguntas = Pregunta.objects.filter(realizador__username=alumno,cuestionario=cuestionario)
        else:
            preguntas = Pregunta.objects.filter(realizador=profile.user,cuestionario=cuestionario)
        return render_to_response('cuestionario/%s/ver_evaluacion_alumno.html'% profile.user.usuario.rol,{'evaluacion':evaluacion,'informacion':k_info},context_instance = RequestContext(request))

    except Cuestionario.DoesNotExist:
        raise PermissionDenied

#@role_required(role='profesor')
@login_required
def ver_evaluacion_alumno(request,slug,id,alumno):
    from cuestionario.models import Evaluacion
    from tarea.models import Pregunta
    from django.shortcuts import get_object_or_404

    profile = request.user.get_profile()
    k_info = get_info(request,profile,slug)
    
    if profile.user.usuario.rol == 'profesor':        
        evaluacion = get_object_or_404(Evaluacion,id=id,tarea__actividades__asignatura__slug__iexact=slug,realizado=True,user__username=alumno)
        #preguntas = Pregunta.objects.filter(actividad=evaluacion.tarea.actividades,realizador=None)

        return render_to_response('cuestionario/%s/ver_evaluacion.html'% request.user.usuario.rol,{'evaluacion':evaluacion,'informacion':k_info,'alumno':alumno},context_instance = RequestContext(request))
    else:
        if alumno != profile.user.username:
            raise PermissionDenied

        evaluacion = get_object_or_404(Evaluacion,id=id,tarea__actividades__asignatura__slug__iexact=slug,realizado=True,user=profile.user)
        return render_to_response('cuestionario/%s/ver_evaluacion.html'% request.user.usuario.rol,{'evaluacion':evaluacion,'informacion':k_info,'alumno':profile.user.username},context_instance = RequestContext(request))


@role_required(role='profesor')
@login_required
def ver_evaluaciones_alumnos(request,slug,actividad):
    from cuestionario.models import Evaluacion

    profile = request.user.get_profile()
    k_info = get_info(request,profile,slug)

    evaluaciones = Evaluacion.objects.filter(tarea__actividades__id__iexact=actividad,tarea__actividades__autor=profile.user,tarea__actividades__asignatura__slug__iexact=slug,realizado=True)

    return render_to_response('cuestionario/%s/listado_evaluaciones.html'% request.user.usuario.rol,{'evaluaciones':evaluaciones,'informacion':k_info},context_instance = RequestContext(request))
