from copy import deepcopy

from django.conf import settings

from django.utils.translation import ugettext as _

from StringIO import StringIO

import datetime

import django.core.urlresolvers

import lxml.etree #@UnresolvedImport

import uuid

from ldt.utils.url import request_with_auth

__BOOLEAN_DICT = {

    'false':False,

    'true':True,

    '0':False,

    '1':True,

    't': True,

    'f':False

}

def reduce_text_node(element_node, xpath_str=None):

    node_list = []

    if xpath_str is not None:

        node_list = element_node.xpath(xpath_str, smart_strings=False)

    else:

        node_list = [element_node.text]

    return reduce(lambda t, s: t + s, node_list , "")

def boolean_convert(bool_val):

    if bool_val is None:

        return False

    if bool_val is True or bool_val is False:

        return bool_val

    key = str(bool_val).lower()

    return __BOOLEAN_DICT.get(key, False)

def generate_uuid():

    return unicode(uuid.uuid1())

class LdtUtils(object):

    def generate_ldt(self, contentList, title=u"", author=u"IRI Web", web_url=u"", startSegment=None, projects=None, types_id_list=None):

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

        doc = lxml.etree.ElementTree(iri)

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

        project.set(u"id", generate_uuid())

        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 != None :

                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 projects is None:

            projects = []

        annotations_nodes = {}

        for project in projects:

            ldtdoc = lxml.etree.fromstring(project.ldt_encoded)

            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:

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

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

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

        if len(annotations_nodes) > 0:

            for content in contentList:

                if content.iri_id in annotations_nodes:

                    contentnode = annotations_nodes[content.iri_id]

                    if contentnode is not None:

                        content_node = lxml.etree.SubElement(annotations, "content")

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

                        content_node.text = u""

                        for ens in contentnode["ensembles"]:

                            content_node.append(ens)

        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)

                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)

                # We add the project's decoupages in the generated project

                if len(annotations_nodes) > 0:

                    if content.iri_id in annotations_nodes:

                        contentnode = annotations_nodes[content.iri_id]

                        if contentnode is not None:

                            for ens in contentnode["ensembles"]:

                                for decoupagenode in ens:

                                    type_id = decoupagenode.get(u"id")

                                    if type_id in types_id_list:

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

                                        decoupage.set(u"id", decoupagenode.get(u"id"))

                                        decoupage.set(u"idens", ens.get(u"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"])

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

        return doc

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

        iri = lxml.etree.Element('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('src', django.core.urlresolvers.reverse(method, args=url))

        if(search):

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

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

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

        return iri 

class LdtAnnotation:

    def __init__(self, project, force_save=False):

        self.project = project

        self.parser = lxml.etree.XMLParser(remove_blank_text=True)

        self.ldtdoc = lxml.etree.parse(StringIO(project.ldt_encoded), self.parser)

        self.to_add = True

    #   add( a['media'], a['type'],  a['type_title, a[data], '', a['tags'], begin, dur, author, date)

    def add(self, media, cutting_id, cutting_title, title, text, tags_list, begin, dur, author, date, view_id="0", color="2194379", audio_scr="", audio_href=""):

        """

        Add an annotation to a project. begin and dur must be strings. Default color is yellow.

        """

        if dur < 0:

            self.to_add = False

            return False

        # We check if the project references the media.

        path_media = self.ldtdoc.xpath('/iri/medias/media[@id="%s"]' % media)

        if len(path_media) == 0:

            self.to_add = False

            return False

        # We get the content node

        path_annotations = self.ldtdoc.xpath('/iri/annotations')[0]

        path_content = path_annotations.xpath('content[@id="%s"]' % media)

        # If the content node does not exist, we create it

        if len(path_content) == 0:

            path_content = lxml.etree.SubElement(path_annotations, 'content')

            path_content.set('id', media)

            path_content = [path_content]

        # We generate the cutting id if necessary

        if cutting_id is None or cutting_id=="" :

            cutting_id = 'c_' + generate_uuid()

        # We get the ensemble node

        path_ensemble = path_content[0].xpath('ensemble[decoupage[@id="%s"]]' % cutting_id)

        if len(path_ensemble) == 0:

            # If the ensemble node does not exist, we create it

            path_ensemble = lxml.etree.SubElement(path_content[0], 'ensemble')

            path_ensemble.set('id', 'g_' + generate_uuid())

            path_ensemble.set('title', _('Personal cutting'))

            path_ensemble.set('author', 'IRI')

            path_ensemble.set('abstract', 'IRI')

            path_ensemble = [path_ensemble]

        #else:

        #    path_ensemble = path_content[0].xpath('ensemble')

        # We get the elements node in the good decoupage node

        ensemble_id = path_ensemble[0].get('id')

        decoupage_elements = path_ensemble[0].xpath('decoupage[@id="%s"]/elements' % cutting_id)

        if len(decoupage_elements) == 0:

            # If the decoupage node does not exist, we create it and its elements node 

            decoupage = lxml.etree.SubElement(path_ensemble[0], 'decoupage')

            #cutting_id = "c_" + generate_uuid()

            decoupage.set('id', cutting_id)

            decoupage.set('author', author)

            decoupage_title = lxml.etree.SubElement(decoupage, 'title')

            decoupage_title.text = cutting_title

            lxml.etree.SubElement(decoupage, 'abstract')

            decoupage_elements = lxml.etree.SubElement(decoupage, 'elements')

            decoupage_elements = [decoupage_elements]

        #else:

        #    cutting_id = path_ensemble[0].xpath('decoupage[title="%s"]' % cutting_title)[0].get('id')     

        # We add the cutting to the view

        if view_id is not None and view_id!="" :

            path_view = self.ldtdoc.xpath('/iri/displays/display[@id="%s"]' % view_id)

            if len(path_view) == 0:

                path_view = self.ldtdoc.xpath('/iri/displays/display[@title="Init view"]')

            else :

                content_display = path_view[0].xpath('content[@id="%s"]' % media)

                if len(content_display) == 0:

                    content_display = lxml.etree.SubElement(path_view[0], 'content')

                    content_display.set('id', media)

                    content_display = [content_display]

                    # We add the decoupage node to the content node

                    dec = lxml.etree.SubElement(content_display[0], 'decoupage')

                    dec.set('idens', ensemble_id)

                    dec.set('id', cutting_id)

                    dec.set('tagsSelect', '')

        # We add the annotation/element node

        element = lxml.etree.SubElement(decoupage_elements[0], 'element')

        id_annotation = 's_' + generate_uuid()

        element.set('id', id_annotation)

        element.set('begin', begin)

        element.set('dur', dur)

        element.set('author', author)

        element.set('date', date)

        element.set('color', color)

        element.set('src', "")

        abstract = lxml.etree.SubElement(element, 'abstract')

        abstract.text = text

        title_node = lxml.etree.SubElement(element, 'title')

        title_node.text = title

        audio = lxml.etree.SubElement(element, 'audio')

        audio.set('source', audio_scr)

        audio.text = audio_href

        tags = lxml.etree.SubElement(element, 'tags')

        polemics = self.get_polemic_syntax(title)

        if polemics:

            meta = lxml.etree.SubElement(element, 'meta')

            polemics_node = lxml.etree.SubElement(meta, 'polemics')

            for polemic in polemics:

                polemic_node = lxml.etree.SubElement(polemics_node, 'polemic')

                polemic_node.text = polemic

        for tag in tags_list:

            tag_node = lxml.etree.SubElement(tags, 'tag')

            tag_node.text = tag

        return cutting_id, id_annotation

    def save(self):

        if self.to_add:

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

            self.project.save()

    def get_polemic_syntax(self, text):

        polemics = []

        for key in settings.SYNTAX.keys():

            if key in text:

                polemics.append(settings.SYNTAX[key])

        return polemics

    def __del__(self):

        self.save()

def create_ldt(project, user, cuttings=[]):

    """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', project.description)

    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 != None :

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

        else:

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

        elementMedia.set('pict', "")

        elementMedia.set('extra', "")

    if not idsel:

        idsel = ""

    #node annotations

    annotations = 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: