from contentindexer import *

from django.conf import settings

from django.contrib.auth.decorators import login_required

from django.core import serializers

from django.core.urlresolvers import reverse

from django.db.models import Q

from django.forms.forms import get_declared_fields

from django.forms.models import model_to_dict

from django.forms.util import ErrorList

from django.http import HttpResponse, HttpResponseRedirect, \

    HttpResponseForbidden, HttpResponseServerError

from django.shortcuts import render_to_response, get_object_or_404, \

    get_list_or_404

from django.template import RequestContext

from django.template.loader import render_to_string

from django.utils import simplejson

from django.utils.html import escape

from django.utils.translation import ugettext as _, ungettext

from fileimport import *

from forms import LdtImportForm, LdtAddForm, SearchForm, AddProjectForm, \

    CopyProjectForm, ContentForm, MediaForm

from ldt.core.models import Owner

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

from ldt.ldt_utils.projectserializer import ProjectSerializer

from ldt.ldt_utils.utils import boolean_convert

from lxml import etree

from lxml.html import fromstring, fragment_fromstring

from models import *

from projectserializer import *

from string import Template

from urllib2 import urlparse

from utils import *

import StringIO

import base64

import cgi

import django.core.urlresolvers

import ldt.auth as ldt_auth

import ldt.utils.path as ldt_utils_path

import logging

import lucene

import lxml.etree

import tempfile

import urllib2

import uuid

@login_required

def workspace(request):

    # list of contents

    content_list = Content.objects.all()

    # get list of projects

    project_list = Project.objects.all()

    # render list

    return render_to_response("ldt/ldt_utils/workspace.html",

                              {'contents': content_list, 'projects': project_list},

                              context_instance=RequestContext(request))

def popup_embed(request):

    json_url = request.GET.get("json_url")

    player_id = request.GET.get("player_id")

    ldt_id = request.GET.get("ldt_id")

    project = Project.objects.get(ldt_id=ldt_id);

    if not ldt_auth.checkAccess(request.user, project):

        return HttpResponseForbidden(_("You can not access this project"))

    ps = ProjectSerializer(project, from_contents=False, from_display=True)

    annotations = ps.getAnnotations(first_cutting=True)

    embed_rendered = dict((typestr,

                           (lambda s:escape(lxml.etree.tostring(fragment_fromstring(render_to_string("ldt/ldt_utils/partial/embed_%s.html"%(s), {'json_url':json_url,'player_id':player_id, 'annotations':annotations, 'ldt_id': ldt_id}, context_instance=RequestContext(request))),pretty_print=True)))(typestr))

                           for typestr in ('player','seo_body', 'seo_meta', 'links')  )

    return render_to_response("ldt/ldt_utils/embed_popup.html",

                              {'json_url':json_url,'player_id':player_id, 'embed_rendered':embed_rendered, 'annotations':annotations},

                              context_instance=RequestContext(request))

@login_required

def projectsfilter(request, filter, is_owner=False, status=0):

    project_list = None

    is_owner = boolean_convert(is_owner)

    status = int(status)

    query = Q()

    if is_owner:

        owner = None

        try:

            owner = Owner.objects.get(user=request.user)

        except:

            return HttpResponseServerError("<h1>User not found</h1>")

        query &= Q(owner=owner)

    if status > 0:

        query &= Q(state=status)

    if filter:

        if len(filter) > 0 and filter[0] == '_':

            filter = filter[1:]

        query &= Q(title__icontains=filter)

    project_list =  Project.objects.filter(query)

    return render_to_response("ldt/ldt_utils/partial/projectslist.html",

                              {'projects': project_list},

                              context_instance=RequestContext(request))

@login_required

def contentsfilter(request, filter):

    if filter and len(filter) > 0 and filter[0] == '_':

        filter = filter[1:]

    if filter:

        content_list = Content.objects.filter(title__icontains=filter)

    else:

        content_list = Content.objects.all()

    return render_to_response("ldt/ldt_utils/partial/contentslist.html",

                              {'contents': content_list},

                              context_instance=RequestContext(request))

def searchForm(request):

    form = SearchForm()

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

def searchIndex(request):

    sform = SearchForm(request.POST)

    if sform.is_valid():

        search = sform.cleaned_data["search"]

        queryStr = base64.urlsafe_b64encode(search.encode('utf8'))

        field = request.POST["field"]

        language_code = request.LANGUAGE_CODE[:2]

        url = settings.WEB_URL + django.core.urlresolvers.reverse("ldt.ldt_utils.views.searchInit", args=[field, queryStr])

        return render_to_response('ldt/ldt_utils/init_ldt.html', {'LDT_MEDIA_PREFIX': settings.LDT_MEDIA_PREFIX, 'colorurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/pkg/color.xml', 'i18nurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/', 'url': url}, context_instance=RequestContext(request))

    else:

        resp = HttpResponse()

        resp.write("<html><head></head><body>Error : No result</body></html>");

def searchIndexGet(request, field, query):

    language_code = request.LANGUAGE_CODE[:2]

    url = settings.WEB_URL + django.core.urlresolvers.reverse("ldt.ldt_utils.views.searchInit", args=[field, query])

    return render_to_response('ldt/ldt_utils/init_ldt.html', {'LDT_MEDIA_PREFIX': settings.LDT_MEDIA_PREFIX, 'colorurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/pkg/color.xml', 'i18nurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/', 'url': url}, context_instance=RequestContext(request))

def searchInit(request, field, query):

    ldtgen = LdtUtils()

    doc = ldtgen.generateInit([field,query], 'ldt.ldt_utils.views.searchLdt', 'ldt.ldt_utils.views.searchSegments')

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

    doc.write(resp, pretty_print=True)

    return resp

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

        searcher = 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 = Content.objects.filter(iri_id__in=id_list)        

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

    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 = etree.SubElement(iri, 'seg')

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

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

            seg.set('iddec', resultMap['decoupage_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") 

@login_required         

def list_ldt(request):

    contents = Content.objects.all()

    try:

        owner = Owner.objects.get(user=request.user)

    except:

        return HttpResponseRedirect(settings.LOGIN_URL)

    ldtProjects = Project.objects.filter(owner=owner)

    context={

    'contents': contents,

    'projects': ldtProjects.reverse(),

    }

    return render_to_response('ldt/ldt_utils/ldt_list.html', context, context_instance=RequestContext(request))

@login_required         

def list_content(request):

    contents = Content.objects.all()

    context={

        'contents': contents,

    }

    return render_to_response('ldt/ldt_utils/content_list.html', context, context_instance=RequestContext(request))

@login_required

def create_ldt_view(request):

    if request.method == "POST" :

        form = LdtAddForm(request.POST)

        if form.is_valid():

            user = request.user

            Project.create_project(title=form.cleaned_data['title'], user=user, contents=form.cleaned_data['contents'])

            form_status = "saved"

            contents=[]

            #return HttpResponseRedirect(reverse("ldt.ldt_utils.views.list_ldt"))

    else:

        form = LdtAddForm()

        contents = Content.objects.all()

        form_status = "none"

    return render_to_response('ldt/ldt_utils/create_ldt.html', {'contents': contents, 'form': form, 'form_status':form_status,'create_project_action':reverse(create_ldt_view)}, context_instance=RequestContext(request))

def created_ldt(request):

    return render_to_response('ldt/ldt_utils/save_done.html', context_instance=RequestContext(request))

def indexProject(request, id):

    urlStr = settings.WEB_URL + reverse("space_ldt_init", args=['ldtProject', id])

    posturl= settings.WEB_URL + reverse("ldt.ldt_utils.views.save_ldtProject")

    language_code = request.LANGUAGE_CODE[:2]

    ldt = get_object_or_404(Project, ldt_id=id)

    if ldt.state ==2: #published

        readonly = 'true'

    else:

        readonly = 'false'

    return render_to_response('ldt/ldt_utils/init_ldt.html', {'LDT_MEDIA_PREFIX': settings.LDT_MEDIA_PREFIX, 'colorurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/pkg/color.xml', 'i18nurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/', 'url': urlStr, 'posturl': posturl, 'id': id, 'readonly': readonly}, context_instance=RequestContext(request))

def init(request, method, url):

    ldtgen = LdtUtils()

    doc = ldtgen.generateInit([url], 'ldt.ldt_utils.views.'+method, None)

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

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

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

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

    return resp

def ldtProject(request, id):

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

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

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

    project = Project.objects.get(ldt_id=id)

    resp.write(project.ldt)

    return resp

def project_json_id(request, id):

    project = get_object_or_404(Project,ldt_id=id)

    return project_json(request, project, False)

def project_json_externalid(request, id):

    res_proj = get_list_or_404(Project.objects.order_by('-modification_date'),contents__external_id = id)

    return project_json(request, res_proj[0], False)

def project_json(request, project, serialize_contents = True):

    if not ldt_auth.checkAccess(request.user, project):

        return HttpResponseForbidden(_("You can not access this project"))

    mimetype = request.REQUEST.get("mimetype")

    if mimetype is None:

        mimetype = "application/json; charset=utf-8"

    else:

        mimetype = mimetype.encode("utf-8")

    if "charset" not in mimetype:

        mimetype += "; charset=utf-8" 

    resp = HttpResponse(mimetype=mimetype)

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

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

    indent = request.REQUEST.get("indent")

    if indent is None:

        indent = settings.LDT_JSON_DEFAULT_INDENT

    else:

        indent = int(indent)

    callback = request.REQUEST.get("callback")

    escape_str = request.REQUEST.get("escape")

    escape_bool = False

    if escape_str:

        escape_bool = {'true': True, 'false': False, "0": False, "1": True}.get(escape_str.lower())

    ps = ProjectSerializer(project, serialize_contents)

    project_dict = ps.serialize_to_cinelab()

    json_str = simplejson.dumps(project_dict, ensure_ascii=False, indent=indent)

    if callback is not None:

        json_str = "%s(%s)" % (callback,json_str)

    if escape_bool:

        json_str = escape(json_str)

    resp.write(json_str)

    return resp

def project_annotations_rdf(request, ldt_id):

    project = Project.objects.get(ldt_id=ldt_id);

    if not ldt_auth.checkAccess(request.user, project):

        return HttpResponseForbidden(_("You can not access this project"))

    mimetype = request.REQUEST.get("mimetype")

    if mimetype is None:

        mimetype = "application/rdf+xml; charset=utf-8"

    else: