# -*- coding: utf-8 -*-

'''

Created on Jan 31, 2012

@author: ymh

'''

from django.conf import settings

from django.core.cache import cache

from django.db.models import Q, Count, Min

from django.http import HttpResponse

from hdabo.models import Tag, Datasheet, TaggedSheet

from hdalab.models import HdaSession, Country, TagYears, DatasheetExtras

from hdalab.models.dataviz import DbpediaFieldsTranslation, DbpediaFields

from hdalab.models.categories import WpCategory

from hdalab.utils import fix_cache_key

import copy

import json

import hmac

import itertools

import uuid

import logging

logger = logging.getLogger(__name__)

def tagtranslation(request):

    lang = request.GET.get('lang',request.LANGUAGE_CODE)

    labels = request.GET.get('labels',None)

    if not labels:

        return HttpResponse(content=json.dumps({}), content_type='application/json')

    labelslist = [lbl.strip() for lbl in labels.split(",")]

    masters = []

    for lbl in labelslist:

        labelqs = Tag.objects.select_related('dbpedia_fields').filter(~Q(dbpedia_uri = None), label__iexact = lbl)[0:1]

        if len(labelqs) > 0:

            tag = labelqs.get()

            if tag.dbpedia_fields:

                masters.append(tag.dbpedia_fields)

    translationqs = DbpediaFieldsTranslation.objects.select_related("master", "master__tag").filter(master__in = masters, language_code=lang)

    translations = dict([(t.master.label, t.label) for t in translationqs])

    return HttpResponse(content=json.dumps(translations), content_type='application/json')

    # recursive function used by cattree

    catlabel = category.label

    tags = Tag.objects.filter(wp_categories__wp_category = category).distinct()

    taglabels = [k for k in dict([(t.label,t.label) for t in tags])]

    resobj = {

          'label': category.label,

          'themes': [],

          'contents': []

      }

    for label in taglabels:

        if label == catlabel:

            globtags[label] = {'level': level, 'access': resobj }

        else:

            tag_in_list = {'label' : label, 'contents': []}

            resobj['themes'].append(tag_in_list)

            globtags[label] = {'level': (level + 1), 'access': tag_in_list }

    if level < max_level:

        subcats = WpCategory.objects.filter(parent_categories__parent_category = category)

        resobj['themes'] += [subcat(subcats[i], globtags, level + 1, max_level ) for i in range(len(subcats))]

    return resobj

def cleantags(category):

    if category.has_key('contents') and len(category['contents']) == 0:

        del category['contents']

    if category.has_key('contents'):

        category['contents'] = sorted(category['contents'], key=lambda content: -content['score'])

    if category.has_key('themes'):

        themes = []

        for theme in category['themes']:

            clean_theme = cleantags(theme)

            if clean_theme.has_key('themes') or clean_theme.has_key('contents'):

                themes.append(clean_theme)

        category['themes'] = sorted(themes, key=lambda cat: cat['label'])

        if len(category['themes']) == 0:

            del category['themes']

    return category

def cattree(request):

    # Gets the category tree from a label

    ROOT_MAX_TAG_ORDER = 8

    MAX_TAG_ORDER = 8

    MAX_LEVEL = 3

    LEVEL_COEFF = 5

    label = request.GET.get('label', None)

    lowerlabel = label.lower()

    globtags = {}

    resobj = {}

    master_category = WpCategory.objects.filter(label__iexact=label)[0:1]

    if len(master_category):

        resobj = subcat(master_category[0], globtags, 1, MAX_LEVEL )

    #datasheets = Datasheet.objects.filter(validated = True, taggedsheet__tag__label__in = tag_list, taggedsheet__order__lte = MAX_TAG_ORDER).distinct()

    datasheets = Datasheet.objects.filter(validated = True, taggedsheet__tag__label__iexact = label, taggedsheet__order__lte = ROOT_MAX_TAG_ORDER).select_related('organisation').distinct()

    for datasheet in datasheets:

        # Calculating where we add the datasheet in the tree

        maintag = None

        maintagscore = -5

        dsscore = 0

        rootscore = 0

        for ts in TaggedSheet.objects.select_related('tag','datasheet').filter(datasheet__id=datasheet.id,order__lte=MAX_TAG_ORDER):

            label = ts.tag.label

            if globtags.has_key(label):

                score = LEVEL_COEFF * globtags[label]['level'] - ts.order

                if score > maintagscore:

                    maintagscore = score

                    maintag = label

                    dsscore = (MAX_TAG_ORDER - ts.order)

                if label.lower() == lowerlabel:

                    rootscore = (ROOT_MAX_TAG_ORDER - ts.order)

        if maintag is not None:

            globtags[maintag]['access']['contents'].append({

                'id': datasheet.id,

                'title': datasheet.title,

                'url': datasheet.url,

                'description': datasheet.description,

                'hda_id': datasheet.hda_id,

                'organization': datasheet.organisation.name,

                'organization_url': datasheet.organisation.website,

                'score': max(dsscore, rootscore)

            })

    if resobj:

        cleantags(resobj)

    elif len(master_category):

        resobj = {

            'label': master_category[0].label,

            'themes': [],

            'contents': []

        }

    else:

        resobj = {

            'label': label,

            'themes': [],

            'contents': []

        }

    return HttpResponse(content=json.dumps(resobj), content_type='application/json')

def sessioninfo(request):

    data = json.loads(request.GET.get('data', "{}"))

    write = False

    if 'sessionid' in request.GET:

        request.session['sessionid'] = request.GET['sessionid']

    if 'sessionkey' in request.GET:

        request.session['sessionkey'] = request.GET['sessionkey']

    if 'sessionid' in request.session:

        sessionid = request.session['sessionid']

        if HdaSession.objects.filter(sessionid=sessionid).count() == 1:

            sessionkey = request.session.get('sessionkey',None)

            hm = hmac.new(settings.SECRET_KEY, sessionid)

            if hm.hexdigest() == sessionkey:

                write = True

        else:

            del request.session['sessionid']

    if 'sessionid' not in request.session:

        sessionid = unicode(uuid.uuid1())

        HdaSession.objects.create(sessionid=sessionid, data=json.dumps({}))

        write = True

        request.session['sessionid'] = sessionid

        request.session['sessionkey'] = hmac.new(settings.SECRET_KEY, sessionid).hexdigest()

    if write and data:

        HdaSession.objects.filter(sessionid=sessionid).update(data=json.dumps(data))

    else:

        data = HdaSession.objects.get(sessionid=sessionid).data

        data = json.loads(data) if data else {}

    resobj = {'data': data, "write_allowed" : write, "sessionid": sessionid }

    if write:

        resobj['sessionkey'] = request.session['sessionkey']

    return HttpResponse(content=json.dumps(resobj), content_type='application/json')

def tagsearch(request):

    q = request.GET.get('term',None)

    maxcount = int(request.GET.get('count','40'))

    lang = request.GET.get('lang',request.LANGUAGE_CODE)

    count_notices_str = request.REQUEST.get("count_notices")

    count_notices_bool = True

    if count_notices_str:

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

    stemming_langs = [ 'fr', 'en', 'de', 'it' ]

    # For Japanese, there are no word boundaries, we should not use the regexp in that case

    no_translate_langs = [ 'fr' ]

    if q:

        lq = q.lower()

        qs = Tag.objects.select_related('dbpedia_fields').filter(datasheet__validated=True)

        qrx = '(\\m|\\b)%s'%q

        if lang in no_translate_langs:

            if lang in stemming_langs:

                qs = qs.filter( label__iregex = qrx )

            else:

                qs = qs.filter( label__icontains = q )

        else:

            if lang in stemming_langs:

                qs = qs.filter(dbpedia_fields__translations__label__iregex=qrx, dbpedia_fields__translations__language_code=lang, dbpedia_fields__translations__is_label_translated = True)

            else:

                qs = qs.filter(dbpedia_fields__translations__label__icontains=q, dbpedia_fields__translations__language_code=lang, dbpedia_fields__translations__is_label_translated = True)

    else:

        qs = Tag.objects.filter(~Q(dbpedia_uri = None))

    if count_notices_bool:

        qs = qs.annotate(nb=Count('datasheet',distinct=True)).order_by('-nb')[:maxcount]

    else:

        qs = qs.distinct()[:maxcount]

    qslist = list(qs)

    if lang in no_translate_langs:

        translations = {}

    else:

        transqs = DbpediaFieldsTranslation.objects.filter(master__tag__in = qslist, language_code=lang, is_label_translated=True).select_related("master")

        translations = dict([(tr.master.tag_id, {'label':tr.label,'abstract':tr.abstract, 'is_label_translated': tr.is_label_translated}) for tr in transqs])

    res = []

    for t in qslist:

        if hasattr(t, 'dbpedia_fields'):

            dbfields = t.dbpedia_fields

            resobj = {'original_label':t.label, 'url':t.wikipedia_url}

            if count_notices_bool:

                resobj['nb'] = t.nb

            resobj['thumbnail'] = dbfields.thumbnail if dbfields is not None else None

            if t.id in translations:

                resobj['value'] = translations[t.id]['label']

                resobj['abstract'] = translations[t.id]['abstract']

            else:

                resobj['value'] = t.label

                resobj['abstract'] = dbfields.abstract if dbfields is not None else None

            if q is None or resobj['value'].lower().find(lq) != -1:

                res.append(resobj)

    return HttpResponse(content=json.dumps(res), content_type='application/json')

def catsearch(request):