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

from django.db import models
from django.contrib.auth.models import User
from django.db.models import signals
from tarea.models import Tarea,Actividad
from autoslug import AutoSlugField

class Evaluacion(models.Model):
    """
    class Evaluacion : Clase encargada de la evaluacion de un determinado usuario    
        :user User: Usuario encargado de corregir una determinada tarea
        :tarea Tarea: Tarea a corregir
        :cuestionario Cuestionario: Cuestionario para evaluar la tarea
        :realizado Boolean: Comprueba si dicha evaluacion se ha corregido
        :nota Integer: Nota asignada a la tarea
    """
    #: Comentario

    user = models.ForeignKey(User,verbose_name="Corrige",related_name="evaluacion_corrector")
    tarea = models.ForeignKey(Tarea,verbose_name="Tarea",related_name="evaluacion_tarea",on_delete=models.CASCADE)
    cuestionario = models.ForeignKey('Cuestionario',verbose_name="Cuestionarios",related_name="cuestionario",on_delete=models.CASCADE)
    realizado = models.BooleanField(default=False,verbose_name='Realizado')
    nota = models.DecimalField(verbose_name="Nota",help_text="Escribe el valor sin %",null=True,blank=True,default=0,max_digits=5,decimal_places=2)

    class Meta:
        verbose_name_plural = "Evaluaciones"    
    def __unicode__(self):
        return u'%s' % (self.user.username)

    class Meta:
        verbose_name = u'Evaluacion'
        verbose_name_plural = u'Evaluaciones'


    def check_complete(self):
        """ 
            Metodo que extrae todas las respuestas de una pregunta
        """
        preguntas = Pregunta.objects.all()
        for pregunta in preguntas:
            respuesta = Respuesta.objects.filter(pregunta = pregunta, user = self.user)
            if len(respuesta) == 0:
                return False
        return True

class Cuestionario(models.Model):
    """
    class Cuestionario : Clase encargada del cuestionario
        :name Char: Nombre asignado al cuestionario
        :text Text: Descripcion del cuestionario, solo se vera en la tabla de los cuestionarios
        :autor User: Autor del cuestionario
        :date Date: Fecha en la que se creo el cuestionario
        :hide Boolean: Permite que sea visible o no a los usuarios.
    """
    name = models.CharField(u"Nombre", max_length=200)
    text = models.TextField(u"Descripcion", help_text = u"Descripcion del cuestionario")
    autor = models.ForeignKey(User,verbose_name="Autor",related_name="cuestionario_autor")
    date = models.DateField(u"Fecha de creacion",auto_now_add=True)
    enddate = models.DateField(u'Fecha final de revision',null=False,blank=False)
    slug = AutoSlugField(null=True,blank=True,populate_from='name',editable=True)
    hide = models.BooleanField(default=False,verbose_name='Publicado')
    actividad = models.OneToOneField(Actividad, help_text = u"Actividad al que pertenece el cuestionario",related_name="cuestionario_actividad",on_delete=models.CASCADE,null=False,blank=True)

    class Meta:
        verbose_name = u'Cuestionario'
        verbose_name_plural = u'Cuestionarios'
        
    def __unicode__(self):
        return u'%s::%s' % (self.name,self.autor)

    def questions(self):
        """
            Metodo que obtiene todas las preguntas de un determinado cuestionario
        """
        return Pregunta.objects.get(cuestionario = self).order_by('nr')


class Pregunta(models.Model):
    """
    class Pregunta: Clase encargada de las preguntas
        :nr Integer: Orden de la pregunta en el cuestionario
        :text Char: Texto de la pregunta
        :type Integer: Tipo de pregunta:\n
                        1. Abierta
                        2. Eleccion
                        3. Multieleccion
                        4. Verdadero/Falso
                        5. Puntuacion
        :cuestionario Cuestionario: Cuestionario al que pertenece
        :val Integer: Valor de la pregunta
    """
    realizador = models.ForeignKey(User,verbose_name="Realizador",related_name="cuestionario_pregunta_realizador",null=True,blank=True,default=None)
    nr = models.IntegerField(u"Numero", help_text = "Orden de la pregunta en el cuestionario")
    text = models.CharField(null=False,blank=False,verbose_name="texto", max_length=500)
    type = models.IntegerField(u"tipo", default=1,choices = ( (1, u'Abierta'), (2, u'Eleccion'), (3, u'Multieleccion'), (4, u'Verdadero/falso') , (5, u'Puntuacion') ), help_text = u"Elige el tipo de respuesta")
    cuestionario = models.ForeignKey(Cuestionario, help_text = u"Cuestionario al que pertenece la pregunta",related_name="pregunta_cuestionario",on_delete=models.CASCADE)
    val = models.PositiveIntegerField(verbose_name="Valor",help_text="Escribe el valor sin %")

    class Meta:
        verbose_name = u'Pregunta'
        verbose_name_plural = u'Preguntas'

    def __unicode__(self):
        return u'%s %s %s' % (str(self.cuestionario), self.nr, self.text)

    def get_choices(self):
        """
            Metodo que obtiene las determinadas elecciones de una pregunta ordenados
        """
        elecciones = Eleccion.objects.filter(pregunta = self).order_by('nr')
        if len(elecciones) == 0:
            return []
        return elecciones

    def get_choices_admin(self):
        """
            Metodo que obtiene las determinadas elecciones para la parte de administracion
        """
        elecciones = Eleccion.objects.filter(pregunta = self).order_by('nr')
        if len(elecciones) == 0:
            return []
        valores = ''
        for i in  range(elecciones.count()):
            valores += str(elecciones[i])+","
        return valores

    def get(self,args):
        return self.nr,self.text,self.type,self.val

class Eleccion(models.Model):
    """
    class Eleccion : Clase encargada de la eleccion de un determinado usuario
    
        :pregunta Pregunta: Pregunta a la que esta relacionada dicha eleccion
        :nr Integer: Numero de la eleccion
        :name Char: Texto de la eleccion
        :val Integer: Valor de la eleccion en positivo
    """
    pregunta = models.ForeignKey(Pregunta,related_name="eleccion_pregunta",on_delete=models.CASCADE)
    nr = models.IntegerField(u"Numero", help_text = u"Orden de la eleccion")
    name = models.CharField(u"Texto", max_length=200)
    val = models.PositiveIntegerField(u"Valor",default=0,null=True,blank=True)
    correct = models.BooleanField("Correcta",default=False,help_text="Marque si es la respuesta correcta")

    class Meta:
        verbose_name = u'Eleccion'
        verbose_name_plural = u'Elecciones'

    def __unicode__(self):
        return u'%s:: %s %s' % (self.id,self.nr, self.name)

    def __str__(self):
        return u'%s' % (self.name)

class Respuesta(models.Model):
    """
        class Respuesta : Clase encargada de la respuesta de un determinada pregunta
            :user User: Usuario encargado de responder una determinada pregunta
            :pregunta Pregunta: Pregunta a la que pertenece
            :respuesta Text: Respuesta para dicha pregunta
    """
    pregunta = models.ForeignKey(Pregunta, help_text = u"Pregunta a responder por el usuario",related_name="respuesta_pregunta",on_delete=models.CASCADE)
    respuesta = models.TextField(u"Respuesta")

    class Meta:
        verbose_name = u'Respuesta'
        verbose_name_plural = u'Respuestas'

    def choice_str(self):
        """
            Metodo que obtiene todas las elecciones y las transforma en string
        """
        choice_string = ""
        elecciones = self.pregunta.get_choices()
        split_answers = self.respuesta.split()

        for eleccion in elecciones:
            for split_answer in split_answers:
                if str(split_answer) == str(eleccion.nr):
                    choice_string += str(eleccion.name) + " " 
        return choice_string

    def __unicode__(self):
        return u'%s %s' % (str(self.pregunta), str(self.respuesta))


def crea_type_puntuacion(sender = None, instance = None,created = False, raw = False,**kwargs):        
    for i in range(10):
        puntuacion = Eleccion.objects.create(pregunta=instance,nr=i,name='%s'%i,correct='s'%i)
        puntuacion.save()

