from django.conf import settings

from django.contrib.auth.decorators import login_required

from django.contrib.auth.models import User, Group

from django.core.urlresolvers import reverse

from django.core.paginator import Paginator, InvalidPage, EmptyPage

from django.db.models import Q

from django.forms.models import model_to_dict

from django.forms.util import ErrorList

from django.http import (HttpResponse, HttpResponseRedirect,

    HttpResponseForbidden, HttpResponseServerError)

from ldt.indexation import get_results_with_context, highlight_documents

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 forms import (LdtAddForm, SearchForm, AddProjectForm, CopyProjectForm,

    ContentForm, MediaForm)

from ldt.ldt_utils.models import Content

from ldt.ldt_utils.utils import boolean_convert, LdtUtils, LdtSearch

from lxml.html import fragment_fromstring

from models import Media, Project

from projectserializer import ProjectSerializer

from urllib2 import urlparse

from operator import itemgetter

from itertools import groupby

import base64

import django.core.urlresolvers

import ldt.auth as ldt_auth

import ldt.utils.path as ldt_utils_path

import logging

import lxml.etree

import mimetypes

import os

import urllib2

import subprocess

import re

import datetime

from django.db.backends.postgresql_psycopg2.base import psycopg2

def import_rs(request):

    # Connexion

    conn = psycopg2.connect(database="test_import_rs", user="admin", password="admin")

    cur = conn.cursor()

    # Get all "regarssignes" contents

    cur.execute("SELECT * from ldt_content")

    rows = cur.fetchall()

    s = "Show me the databases:\n"

    for row in rows:

        s += "\n   " + str(row)

        # (id-0, u'iri_id'-1, u'iri_url'-2, u'videopath'-3, datetime creation_date-4, datetime update_date-5, u'title'-6, description-7, eternal_id-8)

        # (1, u'laurentcantet_entrelesmurs', u'laurentcantet_entrelesmurs/laurentcantet_entrelesmurs.iri', u'rtmp://media.iri.centrepompidou.fr/ddc_player/video/regardssignes/', datetime.datetime(2010, 2, 17, 5, 24, 13, 69794, tzinfo=psycopg2.tz.FixedOffsetTimezone(offset=60, name=None)), datetime.datetime(2010, 2, 17, 5, 24, 13, 91656, tzinfo=psycopg2.tz.FixedOffsetTimezone(offset=60, name=None)), u'Entre Les Murs', None, None)

        # Get duration from the iri file

        prePath = u"/Users/tc/dev/eclipse_workspace/regardssignes_svn/web/static/media/ldt/"

        doc = lxml.etree.parse(prePath + row[2])

        res = doc.xpath("/iri/body/medias/media[@id='video']/video")

        if len(res) > 0:

            try:

                dur = int(res[0].get(u'dur', 0) or 0)

            except:

                dur = 3600000

        else:

            dur = 3600000

        # Build platform media and platform content from "regarssignes" contents

        media = Media.objects.create(external_id=row[8], creation_date=row[4], update_date=row[5], videopath=row[3], duration=dur,

                                     description=row[7], title=row[6], src=(row[1] + u".flv"), mimetype_field="('video/x-flv', None)")

        media.save()

        content = Content.objects.create(iri_id=row[1], iriurl=row[2], creation_date=row[4], update_date=row[5], title=row[6], description=row[7],

                                     content_creation_date=row[4], duration=dur, media_obj=media)

        content.save()

    return HttpResponse(s, mimetype="text/plain")

@login_required

def workspace(request):

    # list of contents

    content_list = Content.objects.all() #@UndefinedVariable

    # get list of projects owned by the current user

    project_list = Project.objects.filter(owner=request.user) #@UndefinedVariable

    is_gecko = ((request.META['HTTP_USER_AGENT'].lower().find("firefox")) > -1);

    # render list

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

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

                               'is_gecko': is_gecko},

                              context_instance=RequestContext(request))

@login_required

def groups(request):

    # get list of all published projects

    group_list = request.user.groups #@UndefinedVariable

    is_gecko = ((request.META['HTTP_USER_AGENT'].lower().find("firefox")) > -1);

    # render list

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

                              {'groups': group_list,

                               'is_gecko': is_gecko},

                              context_instance=RequestContext(request))

@login_required

def published_project(request):

    # get list of all published projects

    project_list = Project.objects.filter(state=2) #@UndefinedVariable

    # Search form

    form = SearchForm()

    is_gecko = ((request.META['HTTP_USER_AGENT'].lower().find("firefox")) > -1);

    # render list

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

                              {'projects': project_list, 'form': form,

                               'is_gecko': is_gecko},

                              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); #@UndefinedVariable

    stream_mode = project.stream_mode

    if stream_mode != "video":

        stream_mode = 'radio'

    player_width = 650

    player_height = 480

    if stream_mode == 'radio':

        player_height = 1

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

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

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

    annotations = ps.get_annotations(first_cutting=True)

    rend_dict = {'json_url':json_url, 'player_id':player_id, 'annotations':annotations, 'ldt_id': ldt_id, 'stream_mode': stream_mode, 'player_width': player_width, 'player_height': player_height}

    embed_rendered = dict((typestr,

                           (lambda s:escape(lxml.etree.tostring(fragment_fromstring(render_to_string("ldt/ldt_utils/partial/embed_%s.html" % (s), rend_dict, context_instance=RequestContext(request))), pretty_print=True)))(typestr))

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

    rend_dict['embed_rendered'] = embed_rendered

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

                              rend_dict,

                              context_instance=RequestContext(request))

@login_required

def projects_filter(request, filter, is_owner=False, status=0, id_group=None):

    is_owner = boolean_convert(is_owner)

    status = int(status)

    query = Q()

    if is_owner:

        owner = None

        try:

            owner = request.user #@UndefinedVariable

        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)

    is_gecko = ((request.META['HTTP_USER_AGENT'].lower().find("firefox")) > -1);

    show_username = False

    if id_group > 0:

        # Get group, user and project_list

        grp = Group.objects.get(id=id_group)  #@UndefinedVariable

        users = User.objects.filter(groups__in=[grp]) #@UndefinedVariable

        query &= Q(owner__in=users) #@UndefinedVariable

        project_list = Project.objects.filter(query).extra(select={'lower_title': 'lower(title)'}).order_by('owner__username', 'lower_title') #@UndefinedVariable

        show_username = True

    else :

        project_list = Project.objects.filter(query) #@UndefinedVariable

    # Template depends on the projects's status

    if status == 2 :

        url_templ = "ldt/ldt_utils/partial/publishedprojectslist.html"

    else :

        url_templ = "ldt/ldt_utils/partial/projectslist.html"

    return render_to_response(url_templ,

                              {'projects': project_list, 'show_username':show_username, 'is_gecko': is_gecko},

                              context_instance=RequestContext(request))

@login_required

def contents_filter(request, filter):

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

        filter = filter[1:]

    if filter:

        content_list = Content.objects.filter(title__icontains=filter) #@UndefinedVariable

    else:

        content_list = Content.objects.all() #@UndefinedVariable

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

                              {'contents': content_list},

                              context_instance=RequestContext(request))

def search_form(request):

    form = SearchForm()

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

@login_required

def search_index(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]

        if request.POST.has_key("ldt_pres"):

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

            return render_to_response('ldt/ldt_utils/init_ldt_full.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:

            results = get_results_with_context(field, search)     

            complete_results = []

            results.sort(key=lambda k: k['iri_id'])

            for iri_id, item in groupby(results, itemgetter('iri_id')):

                try:

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

                except Content.DoesNotExist:

                    continue

                segments = list(item)

                score = sum([seg['score'] for seg in segments])

                if content.description == None:

                    desc = ''

                else:

                    desc = content.description        

                complete_results.append({'list' : segments, 'score' : score, 'content_title' : content.title, 'content_id' : content.iri_id, 'content_description' : desc })

            complete_results.sort(key=lambda k: k['score'])  

            request.session.__setitem__('complete_results', complete_results)

            request.session.__setitem__('search', search)

            request.session.__setitem__('field', field)

            paginator = Paginator (complete_results, settings.LDT_RESULTS_PER_PAGE)

            page = 1

            try:

                results = paginator.page(page)

            except (EmptyPage, InvalidPage):

                results = paginator.page(paginator.num_pages)

            results.object_list = highlight_documents(results.object_list, search, field)

            return render_to_response('ldt/ldt_utils/search_results.html', {'results': results, 'nb_results' : paginator.count, 'search' : search, '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/'}, context_instance=RequestContext(request))   

    else:

def display_highlighted_seg(request, project_id, content_id, ensemble_id, cutting_id, segment_id, full=False):

    url = settings.WEB_URL + reverse("ldt.ldt_utils.views.init_segment", args=[project_id, content_id, ensemble_id, cutting_id, segment_id])

    language_code = request.LANGUAGE_CODE[:2]

    if full:

        return render_to_response('ldt/ldt_utils/init_ldt_full.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:

        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 search_listing(request):

    if not request.session.__contains__('complete_results'):

        msg = _("Please enter valid keywords.")

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

    complete_results = request.session.__getitem__('complete_results')

    search = request.session.__getitem__('search')

    field = request.session.__getitem__('field')

    paginator = Paginator(complete_results, settings.LDT_RESULTS_PER_PAGE)

    language_code = request.LANGUAGE_CODE[:2]

    try:

        page = int(request.GET.get('page', '1'))

    except ValueError:

        page = 1

    try:

        results = paginator.page(page)

    except (EmptyPage, InvalidPage):

        results = paginator.page(paginator.num_pages)

    results.object_list = highlight_documents(results.object_list, search, field)

    return render_to_response('ldt/ldt_utils/search_results.html', {'results': results, 'nb_results' : paginator.count, 'search' : search, '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/'}, context_instance=RequestContext(request))   

def search_index_get(request, field, query):

    language_code = request.LANGUAGE_CODE[:2]

    url = settings.WEB_URL + django.core.urlresolvers.reverse("ldt.ldt_utils.views.search_init", 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 search_init(request, field, query):

    ldtgen = LdtUtils()

    doc = ldtgen.generate_init([field, query], 'ldt.ldt_utils.views.search_ldt', 'ldt.ldt_utils.views.search_segments')

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

    contentList = []

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

    queryStr = ""

    if query and len(query) > 0:        

        queryStr = base64.urlsafe_b64decode(query.encode("ascii")).decode("utf8")