# Create your views here.
from django.http import HttpResponse
from django.shortcuts import render_to_response
from django.template import RequestContext
from pocketfilms import settings
from pocketfilms import version
from pocketfilms.ldt.forms import LdtImportForm
from pocketfilms.ldt.forms import LdtProjectImportForm
from pocketfilms.ldt.forms import SearchForm, LdtForm, reindexForm 
from pocketfilms.ldt.fileimport import *
from pocketfilms.ldt.models import Author, LdtProject, Content
from pocketfilms.ldt.utils import *
import django.core.urlresolvers
import django.utils.http
import pocketfilms.ldt.models
import pocketfilms.utils.zipfileext
import pocketfilms.utils.log
import xml.dom.minidom
import xml.dom.ext
import urllib
import base64
import cgi
from pocketfilms.ldt import STORE
from pocketfilms.ldt import ANALYZER
from string import Template
from Ft.Xml import MarkupWriter

def index(request, url):
    
    urlStr = settings.WEB_URL + django.core.urlresolvers.reverse("pocketfilms.ldt.views.init", args=['ldt', url])
    language_code = request.LANGUAGE_CODE[:2]
    
    return render_to_response('ldt/init_ldt.html', {'MEDIA_URL': settings.MEDIA_URL, 'colorurl': settings.MEDIA_URL+'swf/ldt/pkg/color.xml', 'i18nurl': settings.MEDIA_URL+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.MEDIA_URL+'swf/ldt/', 'url': urlStr}, context_instance=RequestContext(request))

def indexProject(request, id):

    urlStr = settings.WEB_URL + django.core.urlresolvers.reverse("pocketfilms.ldt.views.init", args=['ldtProject', id])
    language_code = request.LANGUAGE_CODE[:2]
    
    return render_to_response('ldt/init_ldt.html', {'MEDIA_URL': settings.MEDIA_URL, 'colorurl': settings.MEDIA_URL+'swf/ldt/pkg/color.xml', 'i18nurl': settings.MEDIA_URL+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.MEDIA_URL+'swf/ldt/', 'url': urlStr}, context_instance=RequestContext(request))
        


def searchIndex(request):
    
    sform = SearchForm(request.POST)
    
    
    queryStr = base64.urlsafe_b64encode(request.POST["search"].encode('utf8'))
    field = request.POST["field"]
    language_code = request.LANGUAGE_CODE[:2]
    #pocketfilms.utils.log.debug(str(form))
    #pocketfilms.utils.log.debug(str(sform.cleaned_data))
    #queryStr = django.utils.http.urlquote_plus(form.search)
    
    url = settings.WEB_URL + django.core.urlresolvers.reverse("pocketfilms.ldt.views.searchInit", args=[field, queryStr])
    return render_to_response('ldt/init_ldt.html', {'MEDIA_URL': settings.MEDIA_URL, 'colorurl': settings.MEDIA_URL+'swf/ldt/pkg/color.xml', 'i18nurl': settings.MEDIA_URL+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.MEDIA_URL+'swf/ldt/', 'url': url}, context_instance=RequestContext(request))

def searchIndexGet(request, field, query):

    language_code = request.LANGUAGE_CODE[:2]
    url = settings.WEB_URL + django.core.urlresolvers.reverse("pocketfilms.ldt.views.searchInit", args=[field, query])
    return render_to_response('ldt/init_ldt.html', {'MEDIA_URL': settings.MEDIA_URL, 'colorurl': settings.MEDIA_URL+'swf/ldt/pkg/color.xml', 'i18nurl': settings.MEDIA_URL+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.MEDIA_URL+'swf/ldt/', 'url': url}, context_instance=RequestContext(request))

def searchInit(request, field, query):
    
    ldtgen = pocketfilms.ldt.utils.LdtUtils()
    
    doc = ldtgen.generateInit([field,query], 'pocketfilms.ldt.views.searchLdt', 'pocketfilms.ldt.views.searchSegments')
    
    resp = HttpResponse(mimetype="text/xml")
    xml.dom.ext.PrettyPrint(doc, resp)
    return resp
    

def init(request, method, url):

    ldtgen = pocketfilms.ldt.utils.LdtUtils()
    
    doc = ldtgen.generateInit([url], 'pocketfilms.ldt.views.'+method, None)
    
    resp = HttpResponse(mimetype="text/xml")
    xml.dom.ext.PrettyPrint(doc, resp)
    return resp



def ldt(request, url):
    
    import Ft
    from Ft.Xml import MarkupWriter
    
    resp = HttpResponse(mimetype="text/xml")
    
    contentList = pocketfilms.ldt.models.Content.objects.filter(iri_id=url)
    
    ldtgen = pocketfilms.ldt.utils.LdtUtils()
    ldtgen.generateLdt(contentList, file=resp, title = contentList[0].title)
    
    return resp
    
def ldtProject(request, id):
    resp = HttpResponse(mimetype="text/xml")
    
    project = pocketfilms.ldt.models.LdtProject.objects.get(id=id)
    template = Template(project.ldt)
    resp.write(template.safe_substitute({'web_url':settings.WEB_URL,'media_url':settings.MEDIA_URL, 'stream_url': settings.STREAM_URL}))
    
    return resp
    



def importFile(request):
    form = LdtImportForm() 
    return render_to_response('ldt/upload_form.html',{'form': form} , context_instance=RequestContext(request))

def importProjectFile(request):
    form = LdtProjectImportForm()
    return render_to_response('ldt/upload_project_form.html',{'form': form}, context_instance=RequestContext(request))

def searchForm(request):
    form = SearchForm()
    return render_to_response('ldt/search_form.html',{'form': form} , context_instance=RequestContext(request))


def uploadFile(request):
    importform = LdtImportForm(request.POST, request.FILES)
    if importform.is_valid():
        pocketfilms.utils.log.debug(request.FILES)
        pocketfilms.utils.log.debug(importform.cleaned_data['author'])
        fi = FileImport(request.FILES['importFile'], importform.cleaned_data['author'])
        fi.processFile()
        fi.close()
        return HttpResponse("File imported")
    else:
        return HttpResponse("Form non valid")

def uploadProjectFile(request):
    importForm = LdtProjectImportForm(request.POST, request.FILES)
    args = {}
    if importForm.is_valid():
        pocketfilms.utils.log.debug(request.FILES)
        pocketfilms.utils.log.debug(importForm.cleaned_data['author'])
        
        filetoprocess = request.FILES['importFile']
        fi = None
        if filetoprocess.name.endswith(".ldt"):
            fi = ProjectFileImport(filetoprocess, importForm.cleaned_data['author'])
        elif filetoprocess.name.endswith(".zip"):
            fi = ZipProjectFileImport(filetoprocess, importForm.cleaned_data['author'])
            
        if fi is not None:
            ids = fi.processFile()
            fi.close()
            args = {'message': "File imported and project id " + unicode(ids) + " created" }
        else:
            non_field_errors = importForm.non_field_errors()
            non_field_errors.append("Error when importing : unknown file type")
            importForm._errors["__all__"] = non_field_errors
            args = {'message': "Can not import file, unknown file type", 'form': importForm}
    else:
        non_field_errors = importForm.non_field_errors()
        non_field_errors.append("Error when importing : invalid form")
        importForm._errors["__all__"] = non_field_errors

        args = {'message': "Error when importing : invalid form", 'form': importForm}
        
    return render_to_response('ldt/upload_project_form.html',args, context_instance=RequestContext(request))


def searchLdt(request, field, query, edition=None):
    
    contentList = []
    resp = HttpResponse(mimetype="text/xml")
    queryStr = ""

    if query and len(query)>0:        
        queryStr = base64.urlsafe_b64decode(query.encode("ascii")).decode("utf8")
        #queryStr = base64.urlsafe_b64decode(query.trim("="))
        searcher = pocketfilms.ldt.utils.LdtSearch()
        ids = {}
        
        for result in searcher.query(field, queryStr):
            ids[result["iri_id"]] = ""            

        id_list = ids.keys()
        
        if edition is not None:
            ids_editions = map(lambda t:t[0], filter(lambda id: id[0] is not None, Speak.objects.filter(session__day__edition=edition).order_by("session__start_ts", "order").values_list("content__iri_id")))            
            id_list = filter(lambda id: id in id_list, ids_editions)
            
        contentList = pocketfilms.ldt.models.Content.objects.filter(iri_id__in=id_list)        

            
    ldtgen = pocketfilms.ldt.utils.LdtUtils()
    ldtgen.generateLdt(contentList, file=resp, title = u"Recherche : " + queryStr)
    
    return resp


def searchSegments(request, field, query, edition=None):
    
    if query and len(query)>0:
        searcher = pocketfilms.ldt.utils.LdtSearch()
        
        queryStr = base64.urlsafe_b64decode(query.encode("ascii")).decode("utf8")
        res = searcher.query(field, queryStr)
    else:
        res = []
        
    iri_ids = None
    
    if edition is not None:
        iri_ids = map(lambda t:t[0], filter(lambda id: id[0] is not None, Speak.objects.filter(session__day__edition=edition).order_by("session__start_ts", "order").values_list("content__iri_id")))

    doc = xml.dom.getDOMImplementation().createDocument(None, "iri", None)

    for resultMap in res:
        if iri_ids is None or resultMap['iri_id'] in iri_ids:
            elem = doc.createElement('seg')
            elem.setAttribute('idctt', resultMap['iri_id'])
            elem.setAttribute('idens', resultMap['ensemble_id'])
            elem.setAttribute('iddec', resultMap['decoupage_id'])
            elem.setAttribute('idseg', resultMap['element_id'])
            elem.setAttribute('idvue', "")
            elem.setAttribute('crit', "")
            doc.documentElement.appendChild(elem)

    return HttpResponse(doc.toprettyxml(encoding='utf-8'), mimetype="text/xml")

def downloadLdt(request):

    if request.method == "POST":
        edition_id = request.POST['edition']
        user = request.POST['author']
   
        #edition = Edition.objects.get(id=edition_id).event_date.year 
        edition = None
        resp = HttpResponse(mimetype="text/xml")
        resp['Content-Disposition'] = "attachment; filename=%s.ldt" % (edition,)
        ids = map(lambda t:t[0], filter(lambda id: id[0] is not None, Speak.objects.filter(session__day__edition=edition_id).order_by("session__start_ts", "order").values_list("content")))
        rawContentList = Content.objects.in_bulk(ids)
        contentList = map(lambda id: rawContentList[id], ids)
        
        ldtgen = pocketfilms.ldt.utils.LdtUtils()
        ldtgen.generateLdt(contentList, file=resp, author=user, title = "ENMI %s" % edition, web_url=settings.WEB_URL, media_url=settings.MEDIA_BASE_URL)
    
        return resp


def exportForm(request):
    form = LdtForm()
    return render_to_response('ldt/export_form.html',{'form': form} , context_instance=RequestContext(request))

def reindex(request):
    
    message = None
    if request.method == "POST":
        form = reindexForm(request.POST)
        if form.is_valid():            
            try:
                writer = lucene.IndexWriter(STORE, ANALYZER, True)
                writer.setMaxFieldLength(1048576)
                contentList = form.cleaned_data["contents"]
                indexer = ContentIndexer(contentList,writer)
                indexer.index_all()
    
                writer.close()
                message = "Indexation ok : " + repr(form.cleaned_data["contents"]) 
                form = reindexForm()
            except Exception, inst:
                non_field_errors = form.non_field_errors()
                non_field_errors.append("Error when reindexing : " + cgi.escape(repr(inst)))
                form._errors["__all__"] = non_field_errors
                #message = "ERROR : " + repr(non_field_errors)
    else:
        form = reindexForm()
        
    return render_to_response('ldt/reindex_form.html', {'form': form, 'message':message}, context_instance=RequestContext(request))

def getXmlFromProjectList(request, projects):
    
    resp = HttpResponse(mimetype="text/xml")
    
    writer = MarkupWriter(resp, indent = u"yes")
    writer.startDocument()
    writer.startElement(u"iri", attributes={u"version": unicode(version.VERSION)})
    writer.startElement(u"projects")
    
    for project in projects:
            writer.startElement(u"project", attributes={"id":unicode(project.id), "url":unicode(settings.WEB_URL + django.core.urlresolvers.reverse('pocketfilms.ldt.views.indexProject',args=[project.id]))})
            writer.startElement(u"authors")
            for author in project.authors.all():
                writer.startElement(u"author")
                writer.simpleElement(u"handle", content=unicode(author.handle))
                writer.simpleElement(u"firstname", content= unicode(author.firstname))
                writer.simpleElement(u"lastname", content=unicode(author.lastname))
                writer.simpleElement(u"email", content=unicode(author.email))
                writer.endElement(u"author")
            writer.endElement(u"authors")
            writer.endElement(u"project")
    
    writer.endElement(u"projects") #</projects>
    writer.endElement(u"iri") #</iri>
    
    return resp


def getProjectFromContentId(request, content_id):

    projects = LdtProject.objects.filter(contents__iri_id__in=[content_id]).distinct()
    
    return getXmlFromProjectList(request, projects)
    

def getProjectFromContentExternalId(request, content_id):

    projects = LdtProject.objects.filter(contents__external_id__in=[content_id]).distinct()
    
    return getXmlFromProjectList(request, projects)
    
    
