# Create your views here.
from django.http import HttpResponse, HttpResponseRedirect
from django.shortcuts import render_to_response
from django.core.urlresolvers import reverse
from django.template import RequestContext, TemplateDoesNotExist
from django.template.loader import get_template
from django.db.models import Q
from enmi.conf.models import Session
from enmi.conf.models import Edition
from enmi.conf.models import Person
from enmi.conf.models import Speak
from enmi.conf.models import Event
from enmi.conf.models import Contribution
from enmi.conf.forms import addContributionForm
from enmi.ldt.forms import SearchForm
import enmi.settings
from django.utils.translation import get_language
from iriuser.ldt.models import LdtProject, Content
from iriuser.userpanel.models import Owner
from iriuser.ldt.utils import create_ldt
from django.contrib.auth.decorators import login_required

def index(request):
    session_list = Session.objects.all().order_by('date')
    return render_to_response('home.html', context_instance=RequestContext(request))

def program(request, edition_code):
    edition = Edition.objects.get(code=edition_code)
    form = SearchForm()
    template = None
    try:
        template = get_template("flatpages/additional/"+edition_code+".html")
    except TemplateDoesNotExist:
        template = None
    needspeakconfirm = False
    for d in edition.days():
        for s in d.sessions():
            for speak in s.speaks():
                if not speak.confirmed:
                    needspeakconfirm = True
                    break

    return render_to_response('program.html', {'edition':edition, 'edition_code': edition_code, 'published':True, "form": form, "additionalLink": True, "compref": (template is not None), "needspeakconfirm": needspeakconfirm}, context_instance=RequestContext(request))

def future(request, edition_code):
    edition = Edition.objects.get(code=edition_code)
    needspeakconfirm = False
    for d in edition.days():
        for s in d.sessions():
            for speak in s.speaks():
                if not speak.confirmed:
                    needspeakconfirm = True
                    break
                
    return render_to_response('program.html', {'edition':edition, 'edition_code': edition_code, 'published':False, "additionalLink": False, "needspeakconfirm": needspeakconfirm}, context_instance=RequestContext(request))

def presentation(request, edition_code):
    edition = Edition.objects.get(code=edition_code)
    return render_to_response('presentation.html', {'edition':edition, 'edition_code': edition_code}, context_instance=RequestContext(request))

def bio(request, edition_code):
    edition = Edition.objects.get(code=edition_code)
    presenters = edition.anchor
    speaker_map = {}
    speaker_list = []
    speaks = Speak.objects.filter(session__day__edition = edition).order_by('session__start_ts', 'order')
    for speak in speaks:
        for person in speak.speakers.all():
            if not speaker_map.has_key(person.id):
                speaker_map[person.id] = True
                speaker_list.append({'session':speak.session,'person':person})
                
    return render_to_response("bio.html", {'edition':edition, 'presenters':presenters, 'speaker_list':speaker_list, 'MEDIA_URL':enmi.settings.MEDIA_URL}, context_instance=RequestContext(request))

def biopopup(request, id):
    person = Person.objects.get(id=id)
    return render_to_response("biopopup.html", {'person':person}, context_instance=RequestContext(request))


def additional(request, edition_code):
    return render_to_response("additional/"+edition_code+".html", context_instance=RequestContext(request))

def about(request):
    return render_to_response("about.html",{'MEDIA_URL':enmi.settings.MEDIA_URL}, context_instance=RequestContext(request))
    
@login_required   
def create_contribution(request, event_id, edition_id):
    #get event
    event = Event.objects.get(id=event_id) #foreign key for event
    #get list contents
    # contentList = speak.objects.filter(Q(session__day__edition__id = event_id) | Q(session__day__id =event_id) | Q(session__id = event_id)).values_list("content__iri_id")    
    speaks = Speak.objects.filter(Q(session__day__edition__id = event_id) | Q(session__day__id =event_id) | Q(session__id = event_id) | Q(id =event_id))
    speaks=speaks.order_by('session','order')
    if request.method == "POST" :
        form = addContributionForm(request.POST)
        if form.is_valid():
            #get user
            user=request.user
            owner = Owner.objects.get(user=user)
            #create project ldt
            # project = LdtProject(title=request.POST['title'], contents=contents)
            project = LdtProject(title=request.POST['title'], owner=owner)
            project.save()
            for speak in speaks:
                content = speak.content.content_base
                project.contents.add(content)
            project.save()
            # write xml to ldt
            project=create_ldt(project, user)
            edition = Edition.objects.get(id=edition_id)
            contribution = Contribution(event=event, ldtproject=project, edition=edition)
            contribution.save()
            return HttpResponseRedirect(reverse('iriuser.ldt.views.indexProject', args=[project.ldt_id]))
        
    else:
        form = addContributionForm
    return render_to_response('create_contribution.html', {'form':form, 'speaks':speaks}, context_instance=RequestContext(request))

def list_contribution(request, event_id):
    event = Event.objects.get(id=event_id)
    contributions = Contribution.objects.filter(event=event).filter(ldtproject__state=2)
    return render_to_response('contributions.html', {'contributions': contributions, }, context_instance=RequestContext(request))
    
def loading(request):
    return render_to_response('loading.html', context_instance=RequestContext(request))