# -*- 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
from django.conf import settings
from django.contrib.auth.decorators import login_required
from django.core.urlresolvers import reverse
from django.forms.models import model_to_dict
from django.core.exceptions import PermissionDenied


from app.deco import role_required,owner_required

from tarea.models import Actividad,Pregunta as PreguntaActividad,Eleccion as EleccionActividad
from app.models import Asignatura
from app.views import get_info,comprueba_referido

@login_required
@role_required(role='profesor')
def actividad_wizard(request,slug,id=None):
    profile = request.user.get_profile()
    num_actividad = Actividad.objects.filter(autor=profile.user,asignatura__slug__iexact=slug).count()
    if id is None:
        return crear_actividad(request,slug,profile,num_actividad)
    else:
        return editar_actividad(request,slug,id,profile)

def crear_actividad(request,slug,profile,num_actividad):
    from formwizard.forms import Add_Form_Actividad
    k_info = get_info(request,profile,slug)
    if profile.user.is_authenticated() and request.method == 'POST':
        actividad_form = Add_Form_Actividad(request.POST)
        if actividad_form.is_valid():
            actividad = actividad_form.save(commit = False)
            actividad.nr = num_actividad + 1
            actividad.autor = profile.user
            actividad.asignatura = Asignatura.objects.get(slug__iexact=slug)
            actividad.save()
            return HttpResponseRedirect(reverse('formwizard.views.actividad_pregunta_wizard',args=[slug,actividad.id]))
    else:
        actividad_form = Add_Form_Actividad()

    return render_to_response('formwizard/%s/tarea/add/tarea.html'% request.user.usuario.rol,{'form':actividad_form,'informacion':k_info},context_instance = RequestContext(request))


def editar_actividad(request,slug,id,profile):
    from formwizard.forms import Add_Form_Actividad
    k_info = get_info(request,profile,slug)

    actividad = Actividad.objects.get(id__iexact=id, asignatura__slug__iexact=slug)
    if profile.user.is_authenticated() and request.method =='POST':
        form  = Add_Form_Actividad(request.POST,instance=actividad)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect(reverse('formwizard.views.cuestionario_wizard',args=[slug,actividad.id]))
    else:
        dictionary = model_to_dict(actividad, fields=[], exclude=[])
        form = Add_Form_Actividad(dictionary)

    return render_to_response('formwizard/%s/tarea/edit/tarea.html'% request.user.usuario.rol,{'form':form,'step0':actividad.id,'informacion':k_info},context_instance = RequestContext(request))

@login_required
@role_required(role='profesor')
@owner_required(model='Actividad')
def borrar_actividad_wizard(request,slug,id):
    profile = request.user.get_profile()
    k_info = get_info(request,profile,slug)
    query = Actividad.objects.get(id__iexact=id, asignatura__slug__iexact=slug,autor=profile.user)


    # Actualizamos los numeros de nuevo
    for q in Actividad.objects.filter(asignatura__slug__iexact=slug,autor=profile.user):
        if q.nr > query.nr:
            q.nr = q.nr - 1
            q.save()
    
    query.delete()
    return comprueba_referido(request)


@login_required
@role_required(role='profesor')
@owner_required(model='Actividad')
def actividad_pregunta_wizard(request,slug,id,pregunta=None):
    profile = request.user.get_profile()

    if pregunta:
        try:
            query = PreguntaActividad.objects.get(nr__exact = pregunta,actividad__id__iexact=id,realizador=None,pregunta_evaluada=None)
            return editar_pregunta_actividad_wizard(request,slug,id,profile,query)

        except PreguntaActividad.DoesNotExist:
            return HttpResponseRedirect(reverse('formwizard.views.actividad_pregunta_wizard',args=[slug,id]))
    else:
        return crear_pregunta_actividad_wizard(request,slug,id,profile)



def crear_pregunta_actividad_wizard(request,slug,id,profile):
    from formwizard.forms import ActividadPreguntaForm
    query = Actividad.objects.get(id__iexact = id)
    preguntas = PreguntaActividad.objects.filter(actividad__id__iexact=id,realizador=None,pregunta_evaluada=None)
    num_pregunta  = preguntas.count()
    k_info = get_info(request,profile,slug)

    if profile.user.is_authenticated() and request.method == 'POST':
        form = ActividadPreguntaForm(request.POST)
        if form.is_valid():
            question = form.save(commit = False)
            question.nr = num_pregunta + 1
            question.actividad = query
            question.save()

            question.pk = None
            question.id = None
            question.text= 'Califica'
            question.save()

            for i in range(1,11):
                eleccion =  EleccionActividad(nr=i,name=str(i),val=float(10),correct=True,pregunta=question)
                eleccion.save()


            preguntas = PreguntaActividad.objects.filter(nr=question.nr,realizador=None,actividad=question.actividad).order_by('id')
            preguntas[0].tarea_pregunta_evaluada_actividad.add(preguntas[1])
            preguntas[0].save()

            crear_eleccion_actividad(question.type,preguntas[0].id)
            if question.type == 2 or question.type == 3:
                return HttpResponseRedirect(reverse('aniadir_eleccion_pregunta_actividad_wizard',args=[slug,id,question.nr]))
                
            return HttpResponseRedirect(reverse('editar_actividad_wizard',args=[slug,id]))

        return HttpResponseRedirect(reverse('editar_actividad_wizard',args=[slug,id]))
    else:
        form = ActividadPreguntaForm()

    return render_to_response('formwizard/%s/tarea/add/pregunta.html'% request.user.usuario.rol,{'form':form,'step0':id,'informacion':k_info},context_instance = RequestContext(request))


def editar_pregunta_actividad_wizard(request,slug,id,profile,query):
    from formwizard.forms import ActividadEditPreguntaForm
    k_info = get_info(request,profile,slug)

    if profile.user.is_authenticated() and request.method =='POST':
        form = ActividadEditPreguntaForm(request.POST,instance=query)
        if form.is_valid():
            question = form.save(commit = False)
            question.save()
            return HttpResponseRedirect(reverse('editar_actividad_wizard',args=[slug,id]))
    else:    
        dictionary = model_to_dict(query, fields=[], exclude=[])
        form = ActividadEditPreguntaForm(dictionary)

    return render_to_response('formwizard/%s/tarea/edit/pregunta.html'% request.user.usuario.rol,{'form':form,'step0':id,'informacion':k_info},context_instance = RequestContext(request))



@login_required
@role_required(role='profesor')
@owner_required(model='Actividad')
def actividad_borrar_pregunta_wizard(request,slug,id,pregunta,asignatura=None):
    from tarea.models import Pregunta as PreguntaActividad
    profile = request.user.get_profile()

    try:
        query = PreguntaActividad.objects.get(nr__exact = pregunta,actividad__id__iexact=id,realizador=None,pregunta_evaluada=None)
        return borrar_pregunta_wizard(request,id,profile,query)
 
    except PreguntaActividad.DoesNotExist:
        return comprueba_referido(request)



def borrar_pregunta_wizard(request,id,profile,query):
    if profile.user.is_authenticated() and query.actividad.autor == profile.user:

        # Borramos las preguntas asociadas
        query_asociados = PreguntaActividad.objects.filter(nr__iexact=query.nr,actividad__id__iexact=id).exclude(realizador=None,pregunta_evaluada=None)
        query_asociados.delete()

        # Actualizamos los numeros de nuevo
        for q in query.actividad.tarea_pregunta_actividad.all():
            if q.nr > query.nr:
                q.nr = q.nr - 1
                q.save()
        
        query.delete()
        return comprueba_referido(request)

    else:
        return comprueba_referido(request)


@login_required
@role_required(role='profesor')
def actividad_pregunta_eleccion_wizard(request,slug,id,pregunta,eleccion):
    """TODO"""
    try:
        query = EleccionActividad.objects.get(nr__iexact=eleccion,pregunta__id=pregunta,pregunta__actividad__id=id)

    except EleccionActividad.DoesNotExist:
        pass

def crear_eleccion_actividad(type,pregunta):
    query =  PreguntaActividad.objects.get(id__iexact=pregunta,realizador=None,pregunta_evaluada=None)
    if type == 4:
        verdadero = EleccionActividad(nr=1,name='Verdadero',correct=True,val=0,pregunta=query)
        verdadero.save()
        falso = EleccionActividad(nr=2,name='Falso',val='0',pregunta=query)
        falso.save()
    if type == 5:
        for i in range(1,11):
            respuesta =  EleccionActividad(nr=i,name=str(i),val=(float(query.val)/10)*i,correct=True,pregunta=query)
            respuesta.save()

@login_required
@role_required(role='profesor')
@owner_required(model='Actividad')
def selecciona_eleccion_actividad(request,slug,id,pregunta,eleccion):
    try :
        query =  EleccionActividad.objects.get(id__iexact=eleccion,pregunta__id__iexact=pregunta,pregunta__actividad__id__iexact=id)
        if query.pregunta.type == 2:
            return selecciona_respuesta_eleccion_actividad(request,id,pregunta,eleccion,query)

        if query.pregunta.type == 3:
            return selecciona_multirespuesta_eleccion_actividad(request,id,pregunta,eleccion,query)       
        
        elif query.pregunta.type == 4:
            selecciona_verdadero_falso_eleccion_actividad(request,id,pregunta,eleccion,query)
            return comprueba_referido(request)

        elif query.pregunta.type == 5:
            return comprueba_referido(request)

        else:
            pass
    except EleccionActividad.DoesNotExist:
        return comprueba_referido(request)


def selecciona_respuesta_eleccion_actividad(request,id,pregunta,eleccion,query):
    """TODO"""
    otraEleccion  = None
    if query.correct:
        if query.nr != 1:
            query.correct=False
            query.val = 0

        otraEleccion = query.pregunta.tarea_eleccion_pregunta.all()[0]
        otraEleccion.correct = True
        otraEleccion.val = query.pregunta.val
        otraEleccion.save()

    else:
        for q in query.pregunta.tarea_eleccion_pregunta.all():
            q.correct = False
            q.val = 0
            q.save()
        query.correct = True
        query.val = query.pregunta.val


    query.save()
    return comprueba_referido(request)

def selecciona_multirespuesta_eleccion_actividad(request,id,pregunta,eleccion,query):
    if query.correct:
        query.correct = False
    else:
        query.correct = True

    query.save()
    return comprueba_referido(request)



def selecciona_verdadero_falso_eleccion_actividad(request,id,pregunta,eleccion,query):
    """
    Funcion que permite de/seleccionar una eleccion como verdadera o falsa

    :id: Recibe un id de la actividad con la que esta relacionada
    :pregunta: Pregunta relacionada
    :eleccion: Eleccion a la que se refiere
    :query: Consulta de la eleccion realizada

    .. versionadded: 0.51 alpha
    """
    ##  La eleccion es correcta
    otraEleccion  = None

    if query.correct:
        query.correct = False

        if query.name == u'Verdadero':
            otraEleccion = EleccionActividad.objects.get(id__iexact=int(eleccion)+1,pregunta__id__iexact=pregunta,pregunta__actividad__id__iexact=id)
 
        else:
            otraEleccion = EleccionActividad.objects.get(id__iexact=int(eleccion)-1,pregunta__id__iexact=pregunta,pregunta__actividad__id__iexact=id)

        otraEleccion.correct = True
        otraEleccion.val = otraEleccion.pregunta.val

    ##  La eleccion es incorrecta
    else:
        query.correct = True

        if query.name == u'Verdadero':
            otraEleccion = EleccionActividad.objects.get(id__iexact=int(eleccion)+1,pregunta__id__iexact=pregunta,pregunta__actividad__id__iexact=id)

        else:
            otraEleccion = EleccionActividad.objects.get(id__iexact=int(eleccion)-1,pregunta__id__iexact=pregunta,pregunta__actividad__id__iexact=id)

        otraEleccion.correct = False
        otraEleccion.val = 0

    otraEleccion.save()

    puntuacion = lambda num : query.pregunta.val if query.correct else 0
    query.val = puntuacion(query.pregunta.val)
    query.save()

@login_required
@role_required(role='profesor')
@owner_required(model='Actividad')
def actividad_pregunta_aniadir_eleccion_wizard(request,slug,id,pregunta,asignatura=None):
    """
    Funcion que permite añadir una nueva eleccion a una pregunta

    :id: Recibe un id de la actividad con la que esta relacionada
    :pregunta: Pregunta relacionada
    :asignatura : Asignatura relacionada

    Para la edicion:
    :template: /wizard/tarea/add/add_eleccion.html

    .. versionadded: 0.51 alpha
    """
    """TODO"""
    profile = request.user.get_profile()
    if asignatura:
        pass
    else:
      return  crear_eleccion_pregunta_wizard_without_asignatura(request,slug,id,pregunta,profile)


def crear_eleccion_pregunta_wizard_without_asignatura(request,slug,id,pregunta,profile):
    """ TODO """
    from formwizard.forms import ActividadEleccionForm
    k_info = get_info(request,profile,slug)

    query = PreguntaActividad.objects.get(pregunta_evaluada=None,nr__iexact=pregunta,actividad__id__iexact=id,actividad__autor=profile.user,realizador=None)
    num_pregunta  = query.tarea_eleccion_pregunta.count()

    if profile.user.is_authenticated() and request.method =='POST':
        form = ActividadEleccionForm(request.POST)
        if form.is_valid():
            eleccion = form.save(commit = False)
            eleccion.pregunta = query
            eleccion.nr = num_pregunta +1
            if num_pregunta == 0:
                eleccion.correct = True
                eleccion.val = query.val

            eleccion.save()

            return HttpResponseRedirect(reverse('formwizard.views.actividad_ver_pregunta_wizard',args=[slug,id,pregunta]))
    else:
        form = ActividadEleccionForm()

    return render_to_response('formwizard/%s/tarea/add/eleccion.html'% request.user.usuario.rol,{'form':form,'step0':id,'pregunta':pregunta,'informacion':k_info},context_instance = RequestContext(request))



@login_required
@role_required(role='profesor')
@owner_required(model='Actividad')
def actividad_ver_pregunta_wizard(request,slug,id,pregunta):
    from tarea.models import Pregunta as PreguntaActividad
    profile = request.user.get_profile()
    k_info = get_info(request,profile,slug)

    try:
        query = PreguntaActividad.objects.get(nr__exact = pregunta,actividad__id__iexact=id,realizador=None,pregunta_evaluada=None)
        return render_to_response('formwizard/%s/tarea/view/pregunta.html'% request.user.usuario.rol,{'question':query,'step0':id,'informacion':k_info},context_instance = RequestContext(request))

    except PreguntaActividad.DoesNotExist:
        return comprueba_referido(request)




@login_required
@role_required(role='profesor')
@owner_required(model='Actividad')
def cuestionario_wizard(request,slug,id,cuestionario=None):
    from cuestionario.models import Cuestionario
    profile = request.user.get_profile()
    try:
        """
            Busca si el cuestionario existe, en caso de que exista permite editarlo
        """
        query = Cuestionario.objects.get(actividad__id = id)
        return editar_cuestionario_wizard(request,slug,profile,query,id)

    except Cuestionario.DoesNotExist:
        return crear_cuestionario_wizard(request,slug,profile,id)
@login_required
@role_required(role='profesor')
def crear_cuestionario_wizard(request,slug,profile,id):
    """
    Funcion que permite crear un cuestionario relacionado con una actividad.

    :role: profesor
    :id: Recibe un id de la actividad con la que esta relacionada

    :template: /wizard/cuestionario/edit/edit_cuestionario.html
    

    :rtype: Devuelve un form y una variable step0 que son los enlaces hacia los que puede navegar

    .. versionadded: 0.5 alpha
    """
    from formwizard.forms import NewCuestionarioForm
    from tarea.models import Actividad
    actividad = Actividad.objects.get(id__iexact=id)
    k_info = get_info(request,profile,slug)

    if profile.user.is_authenticated() and request.method =='POST':
        form = NewCuestionarioForm(request.POST)
        if form.is_valid():
            cuestionario = form.save(commit = False)
            cuestionario.text = actividad.text
            cuestionario.name = actividad.name
            cuestionario.autor = profile.user
            cuestionario.actividad = Actividad.objects.get(id__iexact=id)
            cuestionario.save()
            return HttpResponseRedirect(reverse('formwizard.views.cuestionario_pregunta_wizard',args=[slug,id,cuestionario.slug]))
    else:
        form = NewCuestionarioForm()
    return render_to_response('formwizard/%s/cuestionario/add/cuestionario.html'% request.user.usuario.rol,{'form':form,'step0':id,'informacion':k_info},context_instance = RequestContext(request))

@login_required
@role_required(role='profesor')
def editar_cuestionario_wizard(request,slug,profile,query,id):
    """
    Funcion que permite editar un cuestionario relacionado con una actividad
    a partir de una instancia.

    :role: profesor
    :id: Recibe un id de la actividad con la que esta relacionada
    :query: Recibe la instancia del cuestionario

    :template: /wizard/cuestionario/add/add_cuestionario.html
    
    :rtype: Devuelve un form y una variable step0 que son los enlaces hacia los que puede navegar

    .. versionadded: 0.5 alpha
    """
    from formwizard.forms import NewCuestionarioForm
    k_info = get_info(request,profile,slug)

    if profile.user.is_authenticated() and request.method =='POST':
        form = NewCuestionarioForm(request.POST,instance=query)
        if form.is_valid():
            cuestionario = form.save(commit = False)
            cuestionario.save()
            return HttpResponseRedirect(reverse('formwizard.views.repartir_actividad_wizard',args=[slug,id]))
    else:
        dictionary = model_to_dict(query, fields=[], exclude=[])
        form = NewCuestionarioForm(dictionary)
    return render_to_response('formwizard/%s/cuestionario/edit/cuestionario.html'% request.user.usuario.rol,{'form':form,'step0':id,'cuestionario':query.slug,'informacion':k_info},context_instance = RequestContext(request))

@login_required
@role_required(role='profesor')
@owner_required(model='Actividad')
def borrar_cuestionario_wizard(request,slug,id,cuestionario):
    from cuestionario.models import Cuestionario
    profile = request.user.get_profile()
    k_info = get_info(request,profile,slug)
    query = Cuestionario.objects.get(actividad__id__iexact=id,autor=profile.user)
    query.delete()
    return comprueba_referido(request)


@login_required
@role_required(role='profesor')
@owner_required(model='Actividad')
def cuestionario_pregunta_wizard(request,slug,id,cuestionario,pregunta=None):
    profile = request.user.get_profile()
    from cuestionario.models import Pregunta
    if pregunta:
        try:
            query = Pregunta.objects.get(nr__exact = pregunta, cuestionario__slug=cuestionario, cuestionario__actividad__id__iexact=id,realizador=None)
            return editar_pregunta_cuestionario_wizard(request,slug,id,cuestionario,profile,query)

        except Pregunta.DoesNotExist:
            return crear_pregunta_cuestionario_wizard(request,slug,id,cuestionario,profile)
    else:
        return crear_pregunta_cuestionario_wizard(request,slug,id,cuestionario,profile)

def crear_pregunta_cuestionario_wizard(request,slug,id,cuestionario,profile):
    from cuestionario.models import Cuestionario,Pregunta
    k_info = get_info(request,profile,slug)

    query = Cuestionario.objects.get(slug__iexact= cuestionario,actividad__id__iexact=id)
    preguntas = Pregunta.objects.filter(cuestionario__slug__iexact=cuestionario,cuestionario__actividad__id__iexact=id,realizador=None)

    num_pregunta  = preguntas.count()

    from formwizard.forms import NewQuestionForm
    if profile.user.is_authenticated() and request.method == 'POST':
        form = NewQuestionForm(request.POST)
        if form.is_valid():
            question = form.save(commit = False)
            question.nr = num_pregunta + 1
            question.val = 0
            question.cuestionario = query
            question.save()
            crear_eleccion_cuestionario(question.type,question.id)
            if question.type == 2 or question.type == 3:
                return HttpResponseRedirect(reverse('aniadir_eleccion_pregunta_cuestionario_wizard',args=[slug,id,question.cuestionario.slug,question.nr]))

            return HttpResponseRedirect(reverse('formwizard.views.cuestionario_wizard',args=[slug,id]))
    else:
        form = NewQuestionForm()

    return render_to_response('formwizard/%s/cuestionario/add/pregunta.html'% request.user.usuario.rol,{'form':form,'step0':id,'step1':cuestionario,'informacion':k_info},context_instance = RequestContext(request))


def editar_pregunta_cuestionario_wizard(request,slug,id,cuestionario,profile,query):
    from formwizard.forms import Edit_form_Pregunta_Cuestionario
    k_info = get_info(request,profile,slug)

    if profile.user.is_authenticated() and request.method =='POST':
        form = Edit_form_Pregunta_Cuestionario(request.POST,instance=query)
        if form.is_valid():
            question = form.save(commit = False)
            question.save()
        return HttpResponseRedirect(reverse('formwizard.views.cuestionario_wizard',args=[slug,id]))
    else:    
        dictionary = model_to_dict(query, fields=[], exclude=[])
        form = Edit_form_Pregunta_Cuestionario(dictionary)

    return render_to_response('formwizard/%s/cuestionario/edit/pregunta.html'% request.user.usuario.rol,{'form':form,'step0':id,'step1':cuestionario,'informacion':k_info},context_instance = RequestContext(request))


@login_required
@role_required(role='profesor')
@owner_required(model='Actividad')
def cuestionario_ver_pregunta_wizard(request,slug,id,cuestionario,pregunta,asignatura=None):
    from cuestionario.models import Pregunta
    profile = request.user.get_profile()
    k_info = get_info(request,profile,slug)

    try:
        query = Pregunta.objects.get(nr__exact = pregunta,cuestionario__slug=cuestionario,realizador=None)
        return render_to_response('formwizard/%s/cuestionario/view/pregunta.html'% request.user.usuario.rol,{'question':query,'step0':id,'cuestionario':cuestionario,'informacion':k_info},context_instance = RequestContext(request))

    except Pregunta.DoesNotExist:
        return comprueba_referido(request)



@login_required
@role_required(role='profesor')
@owner_required(model='Actividad')
def cuestionario_borrar_pregunta_wizard(request,slug,id,cuestionario,pregunta,asignatura=None):
    from cuestionario.models import Pregunta
    profile = request.user.get_profile()
    try:
        query = Pregunta.objects.get(nr__exact = pregunta,cuestionario__slug__iexact=cuestionario,cuestionario__actividad__id__iexact=id,realizador=None)
        return borrar_pregunta_cuestionario(request,slug,id,cuestionario,profile,query)
    except Pregunta.DoesNotExist:
        return comprueba_referido(request)

def borrar_pregunta_cuestionario(request,slug,id,cuestionario,profile,query):
    from cuestionario.models import Pregunta

    if profile.user.is_authenticated() and query.cuestionario.autor == profile.user:

        ## Borramos las query asociadas
        query_asociados = Pregunta.objects.filter(nr__iexact=query.nr,cuestionario__slug__iexact=cuestionario).exclude(realizador=None)
        query_asociados.delete()

        ## Actualizamos los numeros
        for q in query.cuestionario.pregunta_cuestionario.all():
            if q.nr > query.nr:
                q.nr = q.nr - 1
                q.save()

        query.delete()
        return comprueba_referido(request)
    else:
        return comprueba_referido(request)

def crear_eleccion_cuestionario(type,pregunta):
    from cuestionario.models import Pregunta,Eleccion
    query =  Pregunta.objects.get(id__iexact=pregunta,realizador=None)
    if type == 4:
        verdadero = Eleccion(nr=1,name='Verdadero',val=0,correct=True,pregunta=query)
        verdadero.save()
        falso = Eleccion(nr=2,name='Falso',val=0,pregunta=query)
        falso.save()
    if type == 5:
        for i in range(1,11):
            respuesta =  Eleccion(nr=i,name=str(i),val=(float(query.val)/10)*i,correct=True,pregunta=query)
            respuesta.save()


@login_required
@role_required(role='profesor')
@owner_required(model='Actividad')
def cuestionario_pregunta_aniadir_eleccion_wizard(request,slug,id,cuestionario,pregunta,asignatura=None):
    from cuestionario.models import Pregunta
    from formwizard.forms import NewChoiceForm
    profile = request.user.get_profile()
    k_info = get_info(request,profile,slug)

    query = Pregunta.objects.get(nr__iexact=pregunta,cuestionario__actividad__id__iexact=id,cuestionario__slug__iexact=cuestionario,cuestionario__actividad__autor=profile.user,realizador=None)
    num_pregunta  = query.eleccion_pregunta.count()

    if profile.user.is_authenticated() and request.method =='POST':
        form = NewChoiceForm(request.POST)
        if form.is_valid():
            eleccion = form.save(commit = False)
            eleccion.pregunta = query
            eleccion.nr = num_pregunta +1
            if num_pregunta == 0:
                eleccion.correct = True
                eleccion.val = query.val

            eleccion.save()

            return HttpResponseRedirect(reverse('formwizard.views.cuestionario_ver_pregunta_wizard',args=[slug,id,cuestionario,pregunta]))
    else:
        form = NewChoiceForm()

    return render_to_response('formwizard/%s/cuestionario/add/eleccion.html'% request.user.usuario.rol,{'form':form,'step0':id,'step1':cuestionario,'pregunta':pregunta,'informacion':k_info},context_instance = RequestContext(request))




@login_required
@role_required(role='profesor')
@owner_required(model='Actividad')
def selecciona_eleccion_cuestionario(request,slug,id,cuestionario,pregunta,eleccion, asignatura=None ):
    from cuestionario.models import Eleccion
    try :
        query =  Eleccion.objects.get(id__iexact=eleccion,pregunta__cuestionario__slug = cuestionario,pregunta__nr=pregunta,pregunta__cuestionario__autor=request.user)
        if query.pregunta.type == 2:
            return selecciona_respuesta_eleccion_cuestionario(request,slug,id,cuestionario,pregunta,eleccion,query)

        if query.pregunta.type == 3:
            return selecciona_multirespuesta_eleccion_cuestionario(request,slug,id,cuestionario,pregunta,eleccion,query)

        elif query.pregunta.type == 4:
            selecciona_verdadero_falso_eleccion_cuestionario(request,id,cuestionario,pregunta,eleccion,query)
            return comprueba_referido(request)
           
        elif query.pregunta.type == 5:
            return comprueba_referido(request)          
        else:
            pass
    except Eleccion.DoesNotExist:
        return comprueba_referido(request)

def selecciona_respuesta_eleccion_cuestionario(request,slug,id,cuestionario,pregunta,eleccion,query):
    """TODO"""
    otraEleccion  = None
    if query.correct:
        if query.nr != 1:
            query.correct=False
            query.val = 0

        otraEleccion = query.pregunta.eleccion_pregunta.all()[0]
        otraEleccion.correct = True
        otraEleccion.val = query.pregunta.val
        otraEleccion.save()

    else:
        for q in query.pregunta.eleccion_pregunta.all():
            q.correct = False
            q.val = 0
            q.save()
        query.correct = True
        query.val = query.pregunta.val


    query.save()
    return comprueba_referido(request)

def selecciona_multirespuesta_eleccion_cuestionario(request,slug,id,cuestionario,pregunta,eleccion,query):
    if query.correct:
        query.correct = False
    else:
        query.correct = True

    query.save()
    if request.META.has_key( 'HTTP_REFERER' ):
        return HttpResponseRedirect(request.META['HTTP_REFERER'])
    else:
        raise PermissionDenied

def selecciona_verdadero_falso_eleccion_cuestionario(request,id,cuestionario,pregunta,eleccion,query):
    from cuestionario.models import Eleccion
    """
    Funcion que permite de/seleccionar una eleccion como verdadera o falsa

    :id: Recibe un id de la actividad con la que esta relacionada
    :pregunta: Pregunta relacionada
    :eleccion: Eleccion a la que se refiere
    :query: Consulta de la eleccion realizada

    .. versionadded: 0.51 alpha
    """
    ##  La eleccion es correcta
    #otraEleccion  = None

    if query.correct:
        query.correct = False
        query.save()

        if query.name == u'Verdadero':
            otraEleccion = Eleccion.objects.get(id__iexact=int(eleccion)+1)
            #return HttpResponseRedirect(reverse('formwizard.views.cuestionario_ver_pregunta_wizard',args=[slug,id,cuestionario,pregunta]))
            
            otraEleccion.correct = True
            otraEleccion.val = 0
            otraEleccion.save()

        else:
            otraEleccion = Eleccion.objects.get(id__iexact=int(eleccion)-1)
            otraEleccion.correct = True
            otraEleccion.val = 0
            otraEleccion.save()


        puntuacion = lambda num : query.pregunta.val if query.correct else 0
        query.val = puntuacion(query.pregunta.val)
        query.save()

    else :
        query.correct = True
        query.save()

        if query.name == u'Verdadero':
            otraEleccion = Eleccion.objects.get(id__iexact=int(eleccion)+1)
            otraEleccion.correct = False
            otraEleccion.val = 0
            otraEleccion.save()

        else:
            otraEleccion = Eleccion.objects.get(id__iexact=int(eleccion)-1)
            otraEleccion.correct = False
            otraEleccion.val = 0
            otraEleccion.save()


        puntuacion = lambda num : query.pregunta.val if query.correct else 0
        query.val = puntuacion(query.pregunta.val)
        query.save()


@login_required
@role_required(role='profesor')
def repartir_actividad_wizard(request,slug,id):
    profile = request.user.get_profile()
    k_info = get_info(request,profile,slug)

    actividad = Actividad.objects.get(id__iexact=id)
    return render_to_response('formwizard/%s/cuestionario/add/distribute.html'% request.user.usuario.rol,{'step0':actividad.id,'step1':actividad.cuestionario_actividad.slug,'informacion':k_info},context_instance = RequestContext(request))


@login_required
@role_required(role='profesor')
def publicar_actividad_wizard(request,slug,id):
    from django.http import HttpResponse
    from cuestionario.models import Cuestionario
    from tarea.models import Actividad
    query = Actividad.objects.get(id__iexact=id,asignatura__slug__iexact=slug)
    cuestionario = Cuestionario.objects.get(actividad=query)
    profile = request.user.get_profile()
    k_info = get_info(request,profile,slug)


    if profile.user.is_authenticated() and request.POST:
        #data = request.POST['Publicar']
        #query.hide = True if data=='Si' else False
        #query.save()
        #cuestionario.hide = True if data=='Si' else False
        #cuestionario.save()
        reparte_tareas_para_realizar(request,slug,query.id)
        #reparte_tareas_para_correccion(request,id)
        
        return HttpResponseRedirect(reverse('app.views.ver_asignatura',args=[slug]))

    else:
        return render_to_response('formwizard/%s/cuestionario/add/publish.html'% request.user.usuario.rol,{'step0':query.id,'step1':query.cuestionario_actividad.id,'publicado':query.hide,'informacion':k_info},context_instance = RequestContext(request))


@login_required
@role_required(role='profesor')
def reparte_tareas_para_realizar(request,slug,actividad):
    from app.models import Usuario
    from tarea.models import Actividad,Tarea

    usuarios = Usuario.objects.filter(asignaturas__slug__iexact=slug,rol='alumno')
    actividad = Actividad.objects.get(id__iexact=actividad,asignatura__slug__iexact=slug)
    tareas = Tarea.objects.filter(actividades = actividad).count()

    # Hay usuarios matriculados y no tienen la tarea asignada
    if tareas == 0 and (usuarios.count()) > 1:
        for usuario in usuarios:
            tarea = Tarea(user=usuario.user,actividades=actividad,realizado=False)
            tarea.save()


@role_required(role='profesor')
@login_required
def reparte_evaluaciones(request,slug):
    from tarea.models import Actividad
    import datetime
    profile = request.user.get_profile()
    k_info = get_info(request,profile,slug)

    #Tenemos todas las actividades
    actividades = Actividad.objects.filter(autor=profile.user,asignatura__slug__iexact=slug,hide=True,cuestionario_actividad__enddate__gte=datetime.date.today(),tarea_tarea_actividades__realizado=True,tarea_tarea_actividades__evaluacion_tarea=None,enddate__lt = datetime.date.today()).distinct()
    if actividades.count():
        return render_to_response('formwizard/%s/evaluacion/repartir_evaluaciones.html'% request.user.usuario.rol,{'actividades':actividades,'informacion':k_info},context_instance = RequestContext(request))

    else:
        return HttpResponseRedirect(reverse('app.views.ver_asignatura',args=[slug]))


@login_required
@role_required(role='profesor')
def reparte_tareas_para_correccion(request,slug,id):
    from tarea.models import Tarea
    from cuestionario.models import Cuestionario,Evaluacion
    import datetime

    # Tareas realizadas
    tareas = Tarea.objects.filter(actividades__id__iexact = id,actividades__enddate__lt=datetime.date.today(),actividades__asignatura__slug__iexact=slug,realizado=True,actividades__hide=True,)
    cuestionario = Cuestionario.objects.get(actividad__id=id)
    print tareas
    print cuestionario

    #Verificamos que no haya ninguna Evaluacion ya creada, por seguiridad
    evaluaciones = Evaluacion.objects.filter(tarea__actividades__id=id).count()
    print evaluaciones
    # Semilla 
    seed = 1
    print tareas.count()
    # Hay mas de 2 tareas y no hay evaluaciones para dichas tareas 
    if (tareas.count())>=2 and evaluaciones == 0:
        i = 0
        for tarea in tareas:
            evaluacion = Evaluacion(user = tareas[(i+seed)%len(tareas)].user, tarea = tarea , cuestionario = cuestionario)
            evaluacion.save()
            i+=1
    
    return comprueba_referido(request)

@login_required
@role_required(role='profesor')
def oculta_actividad(request,slug,id):
    from tarea.models import Actividad
    from cuestionario.models import Cuestionario

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

    try:
        query = Actividad.objects.get(autor=profile.user,asignatura__slug__iexact=slug,id__iexact=id)
        query.hide = False if query.hide==True else True

        try:
            cuestionario = Cuestionario.objects.get(autor=profile.user,actividad__id__iexact=id,actividad__asignatura__slug__iexact=slug)
            query.cuestionario_actividad.hide = query.hide
            query.save()

            return comprueba_referido(request)

        except Cuestionario.DoesNotExist: 
            return comprueba_referido(request)

    except Actividad.DoesNotExist:
        raise PermissionDenied

