from django.conf import settings

from django.contrib.auth.decorators import login_required

from django.core.urlresolvers import reverse

from django.http import HttpResponse, HttpResponseRedirect

from django.shortcuts import render_to_response, get_object_or_404

from django.template import RequestContext

from ldt.indexation import SimpleSearch

from ldt.ldt_utils.models import Content, Project, Media

from ldt.ldt_utils.searchutils import search_generate_ldt

from ldt.ldt_utils.stat import update_stat_project

from ldt.ldt_utils.utils import LdtUtils, clean_description

from ldt.security.permissionchecker import check_object_perm_for_user

from ldt.security.utils import set_forbidden_stream

from ldt.utils.projectldt_parser import absolute_src_xml, relative_src_xml

from ldt.utils.url import static, absurl, absstatic

from ldt.utils.web_url_management import get_web_url

import base64

import logging

import lxml.etree

logger = logging.getLogger(__name__)

def search_index_get(request, field, query):

    language_code = request.LANGUAGE_CODE[:2]

    colorurl=static("ldt/swf/ldt/pkg/color.xml")

    i18nurl=static("ldt/swf/ldt/pkg/i18n")

    baseurl=static("ldt/swf/ldt/")

    return render_to_response('ldt/ldt_utils/init_ldt.html', {'colorurl': colorurl, 'i18nurl': i18nurl, 'language': language_code, 'baseurl': baseurl, 'url': url}, context_instance=RequestContext(request))

def search_init(request, field, query):

    ldtgen = LdtUtils()

    resp = HttpResponse(mimetype="text/xml;charset=utf-8")

    resp.write(lxml.etree.tostring(doc, pretty_print=True, encoding="utf-8")) 

    return resp

def search_ldt(request, field, query, edition=None, return_project=False, query_encoded=True): 

    resp = HttpResponse(mimetype="text/xml")

    doc, _ = search_generate_ldt(request, field, query)

    doc = absolute_src_xml(doc)

    doc.write(resp, pretty_print=True)

    return resp

def search_segments(request, field, query, edition=None):

    if query and len(query) > 0:

        searcher = SimpleSearch()

        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")))

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

    doc = lxml.etree.ElementTree(iri)

    for resultMap in res:

        if iri_ids is None or resultMap['iri_id'] in iri_ids:

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

            seg.set('idctt', resultMap['iri_id'])

            seg.set('idens', resultMap['ensemble_id'])

            seg.set('iddec', resultMap['cutting_id'])

            seg.set('idseg', resultMap['element_id'])

            seg.set('idvue', "")

            seg.set('crit', "")

    #return doc  

    return HttpResponse(lxml.etree.tostring(doc, pretty_print=True), mimetype="text/xml;charset=utf-8") 

def index_segment(request, project_id, content_id, cutting_id, ensemble_id, segment_id):

    post_url = ""

    language_code = request.LANGUAGE_CODE[:2]

    readonly = 'true'

    template_path = 'ldt/ldt_utils/init_ldt.html'

    colorurl=static("ldt/swf/ldt/pkg/color.xml")

    i18nurl=static("ldt/swf/ldt/pkg/i18n")

    baseurl=static("ldt/swf/ldt/")

    return render_to_response(template_path, {'colorurl': colorurl, 'i18nurl': i18nurl, 'language': language_code, 'baseurl': baseurl, 'url': url_str, 'posturl': post_url, 'id': id, 'readonly': readonly}, context_instance=RequestContext(request))

def init_segment(request, project_id, content_id, ensemble_id, cutting_id, segment_id):

    if project_id != u"_":

        get_object_or_404(Project.safe_objects, ldt_id=project_id)

    ldtgen = LdtUtils()

    return HttpResponse(lxml.etree.tostring(lxml.etree.ElementTree(doc), pretty_print=True), mimetype="text/xml;charset=utf-8")

def highlight_segment(request, project_id, content_id, ensemble_id, cutting_id, segment_id):

    if project_id != u"_":

        get_object_or_404(Project.safe_objects, ldt_id=project_id)

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

    doc = lxml.etree.ElementTree(iri)    

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

    seg.set('idctt', content_id)

    seg.set('idens', ensemble_id)

    seg.set('iddec', cutting_id)

    seg.set('idseg', segment_id)

    seg.set('idvue', "")

    seg.set('crit', "")

    return HttpResponse(lxml.etree.tostring(doc, pretty_print=True), mimetype="text/xml;charset=utf-8") 

def ldt_segment(request, project_id, content_id, ensemble_id, cutting_id, segment_id): 

    resp = HttpResponse(mimetype="text/xml")

    resp['Cache-Control'] = 'no-cache, must-revalidate'

    resp['Pragma'] = 'no-cache'

    if project_id and project_id != "_" :

        project = Project.safe_objects.get(ldt_id=project_id) #@UndefinedVariable

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

        ldtdoc = absolute_src_xml(ldtdoc)

        ldtdoc = set_forbidden_stream(ldtdoc, request.user)

        displays_node = ldtdoc.find("displays")

        if not displays_node:

            displays_node = lxml.etree.SubElement(ldtdoc, u"displays")

        res = displays_node.xpath("display")

        if len(res) > 0:

            display_node = res[0]

        else:

            display_node = lxml.etree.SubElement(displays_node, u"display", attrib={u'id':u'0', u'title': u'generated', u'idsel':unicode(content_id), u'tc':u'0'})

        res = display_node.xpath("content[@id='%s']/decoupage[(@id='%s') and (@idens='%s')]" % (content_id, cutting_id, ensemble_id))

        if len(res) == 0:

            #create node

            res = display_node.xpath("content[@id='%s']" % (content_id))

            if len(res) == 0:

                content_node = lxml.etree.SubElement(display_node, u"content")

            else:

                content_node = res[0]

            lxml.etree.SubElement(content_node, u"decoupage", attrib={u'id':unicode(cutting_id), u'idens':unicode(ensemble_id)})

        active_segment_node = displays_node.find(u"activeSegment")

        if not active_segment_node:

            active_segment_node = lxml.etree.SubElement(displays_node, u"activeSegment")

        id_node = active_segment_node.find(u"id")

        if id_node:

            active_segment_node.remove(id_node)

        lxml.etree.SubElement(active_segment_node, u"id", attrib={u"idctt":unicode(content_id), u"idens": unicode(ensemble_id), "idcut":unicode(cutting_id), u"idseg":unicode(segment_id)})                     

        ldtdoc = set_forbidden_stream(ldtdoc, request.user)

        resp.write(lxml.etree.tostring(ldtdoc, xml_declaration=True, encoding='utf-8', pretty_print=True))

    else:

        # generate ldt from 

        ldtgen = LdtUtils()

        content_list = Content.safe_objects.filter(iri_id=content_id)

        if request.user and request.user.username:

            username = request.user.username

        else:

            username = "webuser"

        start_segment = {

            'idcontent': content_id,

            'idgroup' : ensemble_id,

            'idcutting' : cutting_id,

            'idsegment' : segment_id

        }        

        doc = ldtgen.generate_ldt(content_list, "segment : ", author=username, startSegment=start_segment)

        doc = absolute_src_xml(doc)

        doc = set_forbidden_stream(doc, request.user)

        doc.write(resp, pretty_print=('DEBUG' in dir(settings) and settings.DEBUG))

    return resp

@login_required    

def index_project(request, id, full=False):  # @ReservedAssignment

    posturl = absurl(request, "ldt.ldt_utils.views.lignesdetemps.save_ldt_project")

    language_code = request.LANGUAGE_CODE[:2]

    colorurl = static("ldt/swf/ldt/pkg/color.xml")

    i18nurl = static("ldt/swf/ldt/pkg/i18n")

    baseurl = static("ldt/swf/ldt/")

    audio_record_url = None

    try:

        ldt = Project.safe_objects.get(ldt_id=id)

    except Project.DoesNotExist:

        return HttpResponseRedirect(reverse("ldt.ldt_utils.views.workspace.home"))

    if ldt.state == 2 or not check_object_perm_for_user(ldt, 'change_project', request.user):

        readonly = 'true'

    else:

        readonly = 'false'

        # Add audio annotation feature if possible

        if hasattr(settings, "AUDIO_RECORD_URL"):

            if settings.AUDIO_RECORD_URL and settings.AUDIO_RECORD_URL!="":

                audio_record_url = settings.AUDIO_RECORD_URL

    if full:

        template_path = 'ldt/ldt_utils/init_ldt_full.html'

    else:

        template_path = 'ldt/ldt_utils/init_ldt.html'

    return render_to_response(template_path,

                              {'colorurl': colorurl, 'i18nurl': i18nurl, 'language': language_code,

                                'baseurl': baseurl, 'url': urlStr, 'posturl': posturl,

                                'id': id, 'readonly': readonly, 'audio_record_url': audio_record_url},

                              context_instance=RequestContext(request))

def embed_ldt(request, id):  # @ReservedAssignment

    # Almost identical to index_project but without login_required and less parameters

    posturl = ""

    language_code = request.LANGUAGE_CODE[:2]

    colorurl = absstatic(request, "ldt/swf/ldt/pkg/color.xml")

    i18nurl = absstatic(request, "ldt/swf/ldt/pkg/i18n")

    baseurl = absstatic(request, "ldt/swf/ldt/")

    readonly = 'true'

    template_path = 'ldt/ldt_utils/embed_ldt.html'

    try:

        _ = Project.safe_objects.get(ldt_id=id)

    except Project.DoesNotExist:

        return HttpResponseRedirect(reverse("ldt.ldt_utils.views.workspace.home"))

    return render_to_response(template_path, {'colorurl': colorurl, 'i18nurl': i18nurl, 'language': language_code, 'baseurl': baseurl, 'url': urlStr, 'posturl': posturl, 'id': id, 'readonly': readonly}, context_instance=RequestContext(request))

def init(request, method, url):

    ldtgen = LdtUtils()

    library = doc.xpath('/iri/files/library')[0]

    for c in Content.safe_objects.all().select_related("media_obj"):

        elem = lxml.etree.SubElement(library, 'file')

        elem.set('src', c.iri_url())

        if c.videopath :

            elem.set('video', c.videopath)

        else :

            elem.set('video', '')

        elem.set('title', c.title)

        elem.set('author', '')

        elem.set('category', '')

        elem.set('pict', '')

        elem.set('img', '')

    resp = HttpResponse(mimetype="text/xml")

    resp['Cache-Control'] = 'no-cache, must-revalidate'

    resp['Pragma'] = 'no-cache'

    resp.write(lxml.etree.tostring(doc, pretty_print=True, xml_declaration=True, encoding="utf-8")) 

    return resp

def ldt_project(request, id):  # @ReservedAssignment

    resp = HttpResponse(mimetype="text/xml")

    resp['Cache-Control'] = 'no-cache, must-revalidate'

    resp['Pragma'] = 'no-cache'

    project = Project.safe_objects.get(ldt_id=id) #@UndefinedVariable

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

    doc = set_forbidden_stream(doc, request.user)

    doc = absolute_src_xml(doc)

    resp.write(lxml.etree.tostring(doc, pretty_print=True, xml_declaration=True, encoding="utf-8")) 

    return resp

def save_ldt_project(request):

    if request.method == "POST":

        ldt = request.POST['ldt']

        ldt_id = request.POST['id']

        ldtproject = Project.safe_objects.select_related().get(ldt_id=ldt_id) #@UndefinedVariable

        ldtxml=lxml.etree.fromstring(ldt)

        #save xml ldt

        ldt, _, _ = relative_src_xml(ldtxml)

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

        ldtproject.ldt = ldt

        doc = lxml.etree.fromstring(ldtproject.ldt_encoded)

        result = doc.xpath("/iri/project")

        #set new title

        ldtproject.title = result[0].get("title")

        #get new content list

        new_contents = []

        result = doc.xpath("/iri/medias/media")

        for medianode in result:

            media_id = medianode.get("id")

            new_contents.append(media_id)

            #Put back the video fied from "forbidden_stream_url" to the video url

            if medianode.get("video") == settings.FORBIDDEN_STREAM_URL:

                content = Content.objects.get(iri_id=media_id)

                media = Media.objects.get(id=content.media_obj.id)

                medianode.set('video', media.videopath)

                ldtproject.ldt = lxml.etree.tostring(doc, pretty_print=True)

        check_icon_project = False

        #find contents to remove

        for c in ldtproject.contents.all():

            if not c.iri_id in new_contents:

                ldtproject.contents.remove(c)

                if ldtproject.image == c.image:

                    check_icon_project = True

        #add new contents

        contents_id = [c.iri_id for c in ldtproject.contents.all()]

        for c in new_contents:

            if c not in contents_id:

                content = Content.objects.get(iri_id=c)

                ldtproject.contents.add(content)

        update_stat_project(ldtproject)

        #remove html tags added by flash

        description = ldtproject.get_description(doc)

        new_desc = clean_description(description)

        if new_desc:

            desc_node = doc.xpath('/iri/project')[0]

            desc_node.set('abstract', new_desc)

            ldtproject.ldt = lxml.etree.tostring(doc, pretty_print=True)

        ldtproject.description = new_desc if new_desc else description

        #set a new icon for this project

        if check_icon_project:

            ldtproject.set_icon()

        ldtproject.save()

    else: