# -*- coding: utf-8 -*-
'''
Created on Jan 31, 2012

@author: ymh
'''
from django.conf import settings
from django.db import connection
from django.db.models import Q, Count, Sum
from django.http import HttpResponse
from hdabo.models import Tag, Datasheet, TaggedSheet
from hdalab.models import TagLinks, HdaSession, Country, TagYears, DatasheetExtras
import django.utils.simplejson as json
import hmac
import uuid

def taginfo(request):
    label = request.GET.get('label', None)
    
    resobj = {'requested_label' : label}
        
    resobj["content_count"] = Datasheet.objects.filter(taggedsheet__tag__label__iexact = label).distinct().count()
    
    res = Tag.objects.select_related('dbpedia_fields').filter(label__iexact = label).order_by('-dbpedia_uri')[0:1]
    if len(res) == 1:
        restag = res.get()
        resobj["dbpedia_uri"] = restag.dbpedia_uri
        if resobj["dbpedia_uri"] is not None and restag.dbpedia_fields is not None:
            dbfield = restag.dbpedia_fields
            resobj["abstract"] = dbfield.abstract
            resobj["dbpedia_label"] = dbfield.label
            resobj["thumbnail"] = dbfield.thumbnail
    res = Tag.objects.filter(label__iexact = label).order_by('-wikipedia_url')[0:1]
    if len(res) == 1:
        resobj["wikipedia_url"] = res.get().wikipedia_url
        
    resobj["links"] = [{'subject':tl.subject.label, 'object':tl.object.label} for tl in TagLinks.objects.select_related().filter(Q(subject__label__iexact = label) | Q(object__label__iexact = label))]

    return HttpResponse(content=json.dumps(resobj), mimetype='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), mimetype='application/json')


def tagsearch(request):
    
    q = request.GET.get('term',None)
    qs = Tag.objects.filter(label__icontains = q) if q else Tag.objects.all()        
    res = qs.annotate(nb=Count('datasheet')).order_by('-nb')[:20]
    
    return HttpResponse(content=json.dumps([{'label':t.label,'nb':t.nb} for t in res]), mimetype='application/json')


def filter(request):
    periode = request.GET.get('period',None)
    label = request.GET.get('label', None)
    country = request.GET.get('country', None)
    contentlist = request.GET.get('contentlist', None)
    max_tag_order = request.GET.get('mto', 12)
    content_count = request.GET.get('contentcount', 12)
    tag_count = request.GET.get('tagcount', 30)
    cont_count = 0
    
    globalids = []
    
    tagqs = Tag.objects.exclude(category__label = u"Localisation").exclude(category__label = u"Datation").exclude(category__label = u"Discipline artistique")
    countryqs = Country.objects
    discqs = Tag.objects.filter(category__label = u'Discipline artistique')
    yearqs = TagYears.objects
    
    contentqs = Datasheet.objects.filter(validated=True)

    if label or periode or country or contentlist :
        
        if periode:
            years = periode.split(",")
            start_year = int(years[0])
            end_year = int(years[0:2][-1])
            delta = max(1, (end_year-start_year)/2)
            minstart = start_year - delta
            maxend = end_year + delta
            tagqs = Tag.objects.filter(years__end_year__gte = start_year, 
                                       years__start_year__lte = end_year,
                                       years__end_year__lte = maxend,
                                       years__start_year__gte = minstart)
            globalids += [t.id for t in tagqs]
            contentqs = contentqs.filter(taggedsheet__tag__in = tagqs,
                           taggedsheet__order__lte = max_tag_order)
            
        if label:
            for txtlbl in label.split(","):
                taglblqs = Tag.objects.filter(label__iexact = txtlbl)
                globalids += [t.id for t in taglblqs if t.id not in globalids]
                contentqs = contentqs.filter(taggedsheet__tag__in = taglblqs,
                               taggedsheet__order__lte = max_tag_order)
                    
        if country:
            for country_uri in country.split(","):
                taglblqs = Tag.objects.filter(locatedin__country__dbpedia_uri = country_uri)
                globalids += [t.id for t in taglblqs if t.id not in globalids]
                contentqs = contentqs.filter(taggedsheet__tag__in = taglblqs,
                               taggedsheet__order__lte = max_tag_order)

        tagqs = tagqs.filter(datasheet__in = contentqs)
        countryqs = countryqs.filter(includes__tag__taggedsheet__datasheet__in = contentqs)
        discqs = discqs.filter(datasheet__in = contentqs)
        yearqs = yearqs.filter(tag__taggedsheet__datasheet__in = contentqs)
        
    if contentlist is not None:
        contentqs = contentqs.filter(id__in = contentlist.split(","))
    else:
        contentqs.order_by('?')
            
    cont_count = contentqs.count()
    
    contenus = dict([(content.id, {'score' : 0, 'tags' : [], 'id':content.id, 'title': content.title, 'description': content.description, 'url': content.url}) for content in contentqs[0:content_count]])
    contentids = contenus.keys()
    
    qs = DatasheetExtras.objects.select_related('insee').filter(datasheet__in = contentids)
    for dse in qs:
        contenus[dse.datasheet.id]['coords'] = {'city_name': dse.insee.city_name, 'latitude': dse.insee.latitude, 'longitude': dse.insee.longitude}
    
    qs = TaggedSheet.objects.select_related('tag').filter(datasheet__in = contentids, order__lte = max_tag_order).order_by('order')
    for ts in qs:
        match_tag = ts.tag.id in globalids
        contenus[ts.datasheet.id]['tags'].append({'id': ts.tag.id, 'label':ts.tag.label, 'order':ts.order, 'match': match_tag })
        
        if match_tag:
            contenus[ts.datasheet.id]['score'] += 2*max_tag_order - ts.order
        
    if contentlist is None:
        contenus = sorted(contenus.values(),key=lambda e: -e['score'])
    else:
        contenus = contenus.values()
            
    tagqs = tagqs.annotate(nb=Count('datasheet')).order_by('-nb')[:tag_count]
    tags = [{'id': tag.id, 'label': tag.label, 'score': tag.nb} for tag in tagqs]

    countryqs = countryqs.annotate(nb=Count('includes__tag__taggedsheet'))
    countries = dict([(country.dbpedia_uri, country.nb) for country in countryqs])

    discqs = discqs.annotate(nb=Count('taggedsheet')).order_by('-nb')[:10]
    disciplines = [{'label':tag.label,'score':tag.nb} for tag in discqs]
    
    years = {}
    yearqs = yearqs.annotate(nb=Count('tag__taggedsheet'))
    for ty in yearqs:
        for year in range(ty.start_year, ty.end_year):
            years[year] = ty.nb + years[year] if year in years else 0
            
    yearchange = []
    for year in sorted(years.keys()):
        score = years[year]
        if year < 2011:
            if (year-1 not in years and score != 0) or (year-1 in years and years[year-1] != score):
                yearchange.append({'year': year, 'score': score})
            if year+1 not in years and year != -1 and score != 0:
                yearchange.append({'year': year+1, 'score': 0})

    output = {'count': cont_count, 'contents': contenus, 'tags':tags, 'sparkline':yearchange, 'countries':countries, 'disciplines':disciplines}
    
    return HttpResponse(content=json.dumps(output), mimetype='application/json')
