import lucene

from ldt.ldt_utils import STORE

from ldt.ldt_utils import ANALYZER

import uuid

import django.core.urlresolvers

from django.conf import settings

import urllib

import datetime

import lxml.etree

__BOOLEAN_DICT = {

    'false':False,

    'true':True,

    '0':False,

    '1':True,

    't': True,

    'f':False

}

def boolean_convert(bool):

    if bool is None:

        return False

    if bool is True or bool is False:

        return bool

    key = str(bool).lower()

    return __BOOLEAN_DICT.get(key, False)

def generate_uuid():

    return unicode(uuid.uuid1())

class LdtSearch(object):

    def query(self, field, query):

        indexSearcher = lucene.IndexSearcher(STORE)

        queryParser = lucene.QueryParser(lucene.Version.LUCENE_30, field, lucene.FrenchAnalyzer(lucene.Version.LUCENE_30))

        queryParser.setDefaultOperator(lucene.QueryParser.Operator.AND)

        queryObj = queryParser.parse(query)

        hits = indexSearcher.search(queryObj, settings.LDT_MAX_SEARCH_NUMBER)

        res = []

        for hit in hits.scoreDocs:

            doc = indexSearcher.doc(hit.doc)

            res.append({"iri_id":doc.get("iri_id"),"ensemble_id":doc.get("ensemble_id"),"decoupage_id":doc.get("decoupage_id"), "element_id":doc.get("element_id")})

        indexSearcher.close()

        return res

    def queryAll(self, query):        

        return self.query("all", query)

class LdtUtils(object):

    def generateLdt(self, contentList, file, title = u"", author=u"IRI Web", web_url=u"", media_url="", startSegment = None, contributions=None):

        iri = lxml.etree.Element(u'iri')

        doc = lxml.etree.ElementTree(iri)

        project = lxml.etree.SubElement(iri, u'project')

        project.set(u"id",unicode(str(uuid.uuid1())))

        project.set(u"title",unicode(title))

        project.set(u"user",author)

        project.set(u"abstract",u"")

        medias = lxml.etree.SubElement(iri, u"medias")

        for content in contentList:

            videopath = unicode(settings.STREAM_URL)

            if content.videopath :

                videopath = unicode(content.videopath)

            media = lxml.etree.SubElement(medias, "media")

            media.set(u"id",content.iri_id)

            media.set(u"src",content.iri_url(web_url))

            media.set(u"video",videopath)

            media.set(u"pict",u"")

            media.set(u"extra",u"")

            if contributions is None:

                contributions = []

            annotations_nodes = {}

            for contrib in contributions:

                ldtdoc = lxml.etree.fromstring(contrib.ldtproject.ldt.encode("utf-8"))

                res = ldtdoc.xpath("/iri/annotations/content")

                for content in res:

                    contentid = content.get("id")

                    if annotations_nodes.has_key(contentid):

                        contentnode = annotations_nodes[contentid]

                    else:

                        contentnode = {"id":contentid, "ensembles":[]}

                        annotations_nodes[contentid]=contentnode

                    for ens in content.childNodes:

                        if ens.tag.endswith("ensemble"):

                            contentnode["ensembles"].append(ens.tag)

            if len(annotations_nodes) > 0:

                annotations = lxml.etree.SubElement(iri, "annotations")

                for content in contentList:

                    if content.content_base.iri_id in annotations_nodes:

                        contentnode = annotations_nodes[content.content_base.iri_id]

                        if contentnode is not None:

                            if len(contentnode["ensembles"])>0:

                                content = lxml.etree.SubElement(annotation, "content")

                                content.set("id",contentnode["id"])

                                content.text = u""

                            else:

                                content = lxml.etree.SubElement(annotation, "content")

                                content.set("id",contentnode["id"])

            else:

                annotations = lxml.etree.SubElement(iri, "annotations")

        displays = lxml.etree.SubElement(iri, "displays")

        if len(contentList) > 0:

            display = lxml.etree.SubElement(displays, "display")

            display.set(u"id",u"0")

            display.set(u"title",u"generated")

            display.set(u"idsel",contentList[0].iri_id)

            display.set(u"tc",u"0")

            for content in contentList:

                contentd = lxml.etree.SubElement(display,"content")

                contentd.set(u"id",content.iri_id)

                filepath = urllib.urlopen(content.iri_url())

                udoc = lxml.etree.parse(filepath)

                res = udoc.xpath("/iri/body/ensembles/ensemble/decoupage")

                for decoupagenode in res:

                    decoupage_id = decoupagenode.get(u"id")

                    ensemble_id = decoupagenode.getparent().get(u"id")

                    decoupage_id = decoupagenode.get(u"id")

                    ensemble_id = decoupagenode.getparent().get(u"id")

                    decoupage = lxml.etree.SubElement(contentd,"decoupage")

                    decoupage.set(u"id",decoupage_id)

                    decoupage.set(u"idens",ensemble_id)

            if startSegment is not None:

                activeSegment = lxml.etree.SubElement(display,"activeSegment")

                idas = lxml.etree.SubElement(activeSegment,"id")

                idas.set(u"idctt",startSegment["idcontent"])

                idas.set(u"idens" ,startSegment["idgroup"])

                idas.set(u"idcut",startSegment["idcutting"])

                idas.set(u"idseg",startSegment["idsegment"])

        edits = lxml.etree.SubElement(iri, "edits")

        doc.write(file, pretty_print=True)

    def generateInit(self, url, method, search=None):

        iri = lxml.etree.Element('iri')

        impl = lxml.etree.ElementTree(iri)

        elementFiles = lxml.etree.SubElement(iri,'files')    

        elementInit = lxml.etree.SubElement(elementFiles, 'init')

        elementfile = lxml.etree.SubElement(elementInit, 'file')

        elementfile.set('src',settings.WEB_URL + django.core.urlresolvers.reverse(method, args=url))

        elementfile.set('display', '1')

        if(search):

            elementfile.set("segsel",settings.WEB_URL + django.core.urlresolvers.reverse(search, args=url))   

        # /*chemin video : tant que le serveur de media n'est pas up, */

        elementfile.set('video', settings.STREAM_URL)

        elementfile.set('pict', "")

        elementfile.set('extra', "")    

        elementRecent = lxml.etree.SubElement(elementFiles, 'recent')

        elementLibrary = lxml.etree.SubElement(elementFiles, 'library')

        username = ''

        id = ''

        elementUser = lxml.etree.SubElement(iri, 'user')

        elementUser.set('name', username)

        elementUser.set('id', id)

        return iri 

def create_ldt(project, user):

    """create xml"""

    contentList = project.contents.all()

    # create a dom

    iri = lxml.etree.Element('iri')

    doc = lxml.etree.ElementTree(iri)

    #node project

    elementProject = lxml.etree.SubElement(iri, 'project')

    elementProject.set('abstract', "")

    elementProject.set('title', project.title)

    elementProject.set('user', user.username)

    elementProject.set('id', project.ldt_id)

    #node medias

    elementMedias = lxml.etree.SubElement(iri, 'medias')

    idsel = None      

    for content in contentList:

        if not idsel:

            idsel = content.iri_id

        elementMedia = lxml.etree.SubElement(elementMedias, 'media')

        elementMedia.set('id', content.iri_id)

        elementMedia.set('src', content.iri_url())

        if content.videopath and content.videopath !="":

            elementMedia.set('video', content.videopath)

        else:

            elementMedia.set('video', settings.STREAM_URL)

        elementMedia.set('pict', "")

        elementMedia.set('extra', "")

    if not idsel:

        idsel = ""

    #node annotations

    elementAnnotations = lxml.etree.SubElement(iri, 'annotations')

    #node displays

    elementDisplays = lxml.etree.SubElement(iri, 'displays')

    elementDisplay = lxml.etree.SubElement(elementDisplays, 'display')

    elementDisplay.set('id', '0')

    elementDisplay.set('title', 'Init view')

    elementDisplay.set('idsel', idsel)

    elementDisplay.set('tc', '0')

    elementDisplay.set('zoom', '0')

    elementDisplay.set('scroll', '0')

    elementDisplay.set('infoBAB', '')

    #node content

    for content in contentList:

        elementContent = lxml.etree.SubElement(elementDisplay, 'content')

        elementContent.set('id', content.iri_id)

        if not 'http' in content.iriurl:

        #eg: "iiiielizabethrosse/ENMI08-III_elizabethrosse.iri"

            url = content.iri_url()

        else:

            url =content.iriurl

        file = urllib.urlopen(url)

        doc = lxml.etree.parse(file)

        res = doc.xpath("/iri/body/ensembles/ensemble/decoupage")        

        #node decoupage

        for decoupagenode in res:

            decoupage_id = decoupagenode.get(u"id")

            parent= decoupagenode.getparent()

            ensemble_id = parent.get(u"id")

            elementDecoupage = lxml.etree.SubElement(elementContent, 'decoupage')

            elementDecoupage.set('idens', ensemble_id)

            elementDecoupage.set('id', decoupage_id)

    #node edits

    elementEdits = lxml.etree.SubElement(iri, 'edits')

    #write dom in Project.ldt 

    project.ldt = lxml.etree.tostring(iri, pretty_print=True)

    #save Project

    project.save()

    return project        

def copy_ldt(project, new_project, user):

    new_project.ldt_id = str(uuid.uuid1())

    new_project.created_by=user.username

    new_project.changed_by=user.username

    new_project.state = 1

    contentList=project.contents.all()

    """create xml"""

    ldt = lxml.etree.fromstring(project.ldt.encode("utf-8"))

    res = ldt.xpath("/iri/project")

    for elementProject in res:

        elementProject.set('abstract', "")

        elementProject.set('title', new_project.title)

        elementProject.set('user', user.username)

        elementProject.set('id', new_project.ldt_id)

    new_project.ldt = lxml.etree.tostring(ldt, pretty_print=True)

    #save Project

    new_project.save()

    return new_project

def create_empty_iri(file, content, username):

    iri = lxml.etree.Element('iri')

    doc = lxml.etree.ElementTree(iri)

    head = lxml.etree.SubElement(iri, 'head')

    meta_id = lxml.etree.SubElement(head, 'meta')

    meta_id.set(u'name', u'id')

    meta_id.set(u'content', unicode(content.iri_id))

    meta_title = lxml.etree.SubElement(head, 'meta')

    meta_title.set(u'name',u'title')

    meta_title.set(u'content', unicode(content.title))

    meta_abstract = lxml.etree.SubElement(head, 'meta')

    meta_abstract.set(u'name',u'abstract')

    meta_abstract.set(u'content', unicode(content.description))

    meta_author = lxml.etree.SubElement(head, 'meta')

    meta_author.set(u'name',u'author')

    meta_author.set(u'content', unicode(username))

    meta_contributor = lxml.etree.SubElement(head, 'meta')

    meta_contributor.set(u'name',u'contributor')

    meta_contributor.set(u'content', unicode(username))

    meta_date = lxml.etree.SubElement(head, 'meta')

    meta_date.set(u'name',u'date')

    meta_date.set(u'content', unicode(datetime.date.today().isoformat()))

    meta_copyright = lxml.etree.SubElement(head, 'meta')

    meta_copyright.set(u'name',u'copyright')

    meta_copyright.set(u'content', u'IRI')

    meta_type = lxml.etree.SubElement(head, 'meta')

    meta_type.set(u'name', u'type')

    meta_type.set(u'content', u'video')

    body = lxml.etree.SubElement(iri, 'body')

    ensembles = lxml.etree.SubElement(body, 'ensembles')

    links = lxml.etree.SubElement(body, 'links')

    medias = lxml.etree.SubElement(body, 'medias')

    media_video = lxml.etree.SubElement(medias, 'media')

    media_video.set(u'id',u'video')

    video = lxml.etree.SubElement(media_video, 'video')

    video.set(u'src',unicode(content.stream_src))

    video.set(u'id',unicode(content.iri_id))

    video.set(u'dur',unicode(content.duration))

    video.set(u'begin',u'0')

    media_tool = lxml.etree.SubElement(medias, 'media')

    media_tool.set(u'id',u'tool')

    tool = lxml.etree.SubElement(media_tool, 'tool')

    display = lxml.etree.SubElement(body, 'display')

    doc.write(file, pretty_print=True)

def update_iri(filepath, content, username):

    # open xml

    doc = lxml.etree.parse(filepath)

    res = doc.xpath("/iri/head/meta")

    # update meta

    for meta_node in res:

        meta_name = meta_node.get("name")

        content_attr = None

        if meta_name == u'id':

            content_attr = unicode(content.iri_id)

        elif meta_name == u'title':

            content_attr = unicode(content.title)

        elif meta_name == u'abstract':

            content_attr = unicode(content.description)

        elif meta_name == u'contributor':