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

'''

Created on Jul 01, 2014

@author: tc

'''

from datetime import datetime

import json

import logging

from renkanmanager.models import Renkan

from renkanmanager.utils import LineNodePlacer, HorLineNodePlacer, renkan_copier, renkan_deleter, \

    CircleNodePlacer

import uuid

from django.conf import settings

from django.contrib.auth import REDIRECT_FIELD_NAME, login as auth_login, \

    get_user_model

from django.contrib.auth.forms import AuthenticationForm

from django.contrib.sites.models import get_current_site

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

from django.db.models import Q

from django.http import HttpResponse, HttpResponseBadRequest

from django.http import HttpResponseRedirect

from django.http.response import Http404

from django.shortcuts import get_object_or_404, redirect

from django.shortcuts import resolve_url

from django.template.response import TemplateResponse

from django.templatetags.static import static

from django.utils.http import is_safe_url

from django.utils.translation import ugettext as _

from django.views.decorators.cache import never_cache

from django.views.decorators.csrf import csrf_exempt, csrf_protect

from django.views.decorators.debug import sensitive_post_parameters

from django.views.generic import TemplateView, View

from django.views.generic.edit import UpdateView

from hdabo.models import Tag, Datasheet, TaggedSheet, Folder

from hdalab.forms import HdalabRenkanStateForm, HdalabRenkanFavoriteForm

from hdalab.models.dataviz import DbpediaFieldsTranslation

from hdalab.models.renkan import HdalabRenkan

from hdalab.services import change_renkan_state

from hdalab.views.ajax import filter_generic

User = get_user_model()

logger = logging.getLogger(__name__)

class BaseRenkanList(TemplateView):

    def update_context(self, context, renkan_queryset):

        filters = ""

        filter_title = self.request.GET.get("title", "")

        if(len(filter_title)>0):

            renkan_queryset = renkan_queryset.filter(renkan__title__icontains=filter_title)

            filters += "&title=" + filter_title

        filter_username = self.request.GET.get("username", "")

        if(len(filter_username)>0):

            renkan_queryset = renkan_queryset.filter(renkan__owner__username=filter_username)

            filters += "&username=" + filter_username

        filter_state = self.request.GET.get("state", "")

        if(len(filter_state)>0):

            try:

                filter_state = int(filter_state)

            except:

                pass

            renkan_queryset = renkan_queryset.filter(state=filter_state)

            filter_state = str(filter_state)

            filters += "&state=" + filter_state

        filter_startdate = self.request.GET.get("startdate", "")

        if filter_startdate!="":

            renkan_queryset = renkan_queryset.filter(renkan__modification_date__gt=filter_startdate)

            filters += "&startdate=" + filter_startdate

        filter_enddate = self.request.GET.get("enddate", "")

        if filter_enddate!="":

            renkan_queryset = renkan_queryset.filter(renkan__modification_date__lt=filter_enddate + " 23:59:59")

            filters += "&enddate=" + filter_enddate

        filter_favorite = int(self.request.GET.get('favorite', "2"))

        if filter_favorite == 1:

            renkan_queryset = renkan_queryset.filter(favorite=True)

        elif filter_favorite == 0:

            renkan_queryset = renkan_queryset.filter(favorite=False)

        sort_param = self.request.GET.get('sort', "date")

        order_param = self.request.GET.get('order', "desc")

        sort = {"date":"renkan__modification_date", "title":"renkan__title", "state":"state", "user":"renkan__owner__username", "favorite":"favorite"}.get(sort_param, None)

        if order_param=="desc":

            order = "-"

            opposite = "asc"

        else:

            order = ""

            opposite = "desc"

        if sort:

            renkan_queryset = renkan_queryset.order_by(order + sort)

        p = Paginator(renkan_queryset, settings.RENKANS_PER_PAGE)

        page_nb = self.request.GET.get('page')

        try:

            page = p.page(page_nb)

        except PageNotAnInteger:

            page = p.page(1)

        except EmptyPage:

            page = p.page(p.num_pages)

        context.update({"page": page, "sort_param":sort_param, "order_param":order_param, "opposite":opposite, 

                        "filters":filters, "title": filter_title, "username": filter_username, "state": filter_state,

                        "startdate":filter_startdate, "enddate":filter_enddate, "favorite": filter_favorite})

        return context

class ProfileHome(BaseRenkanList):

    template_name = "profile_home.html"

    def get_context_data(self, **kwargs):

        return self.update_context( super(ProfileHome, self).get_context_data(**kwargs), HdalabRenkan.objects.select_related("renkan").filter(renkan__owner=self.request.user))

class RenkanPublicList(BaseRenkanList):

    template_name = "renkan_list.html"

    def get_context_data(self, **kwargs):

class RenkanFavoriteList(BaseRenkanList):

    template_name = "renkan_list.html"

    def get_context_data(self, **kwargs):

        context = super(BaseRenkanList, self).get_context_data(**kwargs)

        context['hide_favorite'] = True

class RenkanNew(View):

    def post(self, request):

        rk = Renkan()

        rk_id = unicode(uuid.uuid1())

        rk.rk_id = rk_id

        rk.owner = request.user

        rk.content = '{}'

        rk.title = "Nouveau Renkan "

        rk.save()

        hr = HdalabRenkan()

        hr.renkan = rk

        hr.state = HdalabRenkan.EDITION

        hr.save()

        return redirect("%s?rk_id=%s" % (reverse('renkan_edit'), rk_id))

class RenkanEdit(TemplateView):

    template_name="renkan_edit.html"

    def get_context_data(self, **kwargs):

        switch_shape_url= {}

        context = super(RenkanEdit, self).get_context_data(**kwargs)

        # If a renkan id is set

        rk_id = self.request.GET.get("rk_id", "")

        if rk_id!="":

            hr = get_object_or_404(HdalabRenkan.objects.select_related("renkan", "renkan__owner"), renkan__rk_id=rk_id) #.get(=rk_id)

            if hr.renkan.owner!=self.request.user or hr.state!=HdalabRenkan.EDITION:

                raise Exception("You are not allowed to edit this renkan")

        else:

            current_url = self.request.get_full_path()

            switch_shape_url["current"] = current_url

            if "shape=horiz" in current_url:

                switch_shape_url["vert"] = current_url.replace("&shape=horiz", "&shape=vert")

                switch_shape_url["circle"] = current_url.replace("&shape=horiz", "")

            elif "shape=vert" in current_url:

                switch_shape_url["horiz"] = current_url.replace("&shape=vert", "&shape=horiz")

                switch_shape_url["circle"] = current_url.replace("&shape=vert", "")

            else:

                #if we generated the renkan from no filter, the url doesn't have any "?"

                #we add one to create the links to the other representation

                if "?" not in current_url:

                    current_url += "?"

                switch_shape_url["horiz"] = current_url + "&shape=horiz"

                switch_shape_url["vert"] = current_url + "&shape=vert"

            context["switch_shape_url"] = switch_shape_url

        form = AuthenticationForm(self.request)

        context["form"] = form

        return context

class HdalabRenkanGetPut(RenkanGetPut):

    @csrf_exempt

    def dispatch(self, *args, **kwargs):

        return super(HdalabRenkanGetPut, self).dispatch(*args, **kwargs)

    def get(self, request):

        # If a renkan id is set

        rk_id = request.GET.get("rk_id", "")

        if rk_id!="":

            rk = get_object_or_404(Renkan, rk_id=rk_id)

            return HttpResponse(rk.content, content_type="application/json")

        shape = request.GET.get("shape", "")

        no_translate_langs = [ 'fr' ]

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

        # Start dict for renkan json

        now = datetime.now().strftime("%Y-%m-%d %H:%M")

        content = {

          "id": unicode(uuid.uuid1()),

          "title": "",

          "description": "(empty description)",

          "created": now,

          "updated": now,

          "nodes": [],

          "edges": [],

          "views": [],

          "users": [],

        }

        # category image dict

        cat_dict = {u"Créateur": static("hdalab/img/category_creator.png"),

                    u"Datation": static("hdalab/img/category_datation.png"),

                    u"Discipline artistique": static("hdalab/img/category_discipline.png"),

                    u"Localisation": static("hdalab/img/category_localisation.png"),

                    u"Ecole/Mouvement": static("hdalab/img/category_movement.png")}

        # category image dict

        shapes = { "tag1": "polygon", "notice": "rectangle", "tag2": "star" }

        # Renkan Project ID

        project_id = unicode(uuid.uuid1())

        # If a notice id is set

        notice_id = request.GET.get("notice", "")

        if notice_id!="":

            notice = get_object_or_404(Datasheet, hda_id=notice_id)

            # We get the ORDERED tags if we display one sheet

            ordered_tags = TaggedSheet.objects.filter(datasheet=notice).select_related("tag", "tag__dbpedia_fields", "tag__category").order_by('order')[:15]

            # Prepare Node placer :

            np = CircleNodePlacer()

            if shape=="horiz":

                np = HorLineNodePlacer()

            elif shape=="vert":

                np = LineNodePlacer()

            np.init({"datasheet": (1, 1), "tags": (2, len(ordered_tags))})

            # Place notice :

            content["nodes"].append({

                "id": unicode(uuid.uuid1()),

                "title": notice.title,

                "description": notice.description,

                "uri": notice.url,

                "position": np.get_place("datasheet"),

                "image": "http://www.histoiredesarts.culture.fr/images/pf/" + notice.hda_id + ".jpg",

                "size": 0,

                "project_id": project_id,

                "color": "#FF0033",

                #"created_by": "roster_user-84fe909f-ba37-48e6-a25f-9d2f129a95b7",

                "shape": shapes["notice"]

            })

            notice_id = content["nodes"][0]["id"]

            # Get translated labels

            translations = {}

            if lang not in no_translate_langs:

                transqs = DbpediaFieldsTranslation.objects.filter(master__in = [ot.tag.dbpedia_fields if hasattr(ot.tag, 'dbpedia_fields') and ot.tag.dbpedia_fields else None for ot in ordered_tags], language_code = lang)

                translations = dict([(trans.master_id,trans) for trans in transqs])

            for ot in ordered_tags:

                t = ot.tag

                img_url = t.dbpedia_fields.thumbnail if hasattr(t, 'dbpedia_fields') and t.dbpedia_fields and t.dbpedia_fields.thumbnail else None

                if img_url is None and t.category is not None:

                    img_url = cat_dict[t.category.label]

                translation_obj = translations.get(t.dbpedia_fields.id, None) if t.dbpedia_fields else None

                translation = {

                    'label': translation_obj.label if translation_obj and translation_obj.label else t.label,

                    'abstract': translation_obj.abstract if translation_obj and translation_obj.abstract else '',

                }

                content["nodes"].append({

                  "id": unicode(uuid.uuid1()),

                  "title": translation['label'],

                  "description": translation['abstract'],

                  "uri": t.wikipedia_url,

                  "position": np.get_place("tags"),

                  "image": img_url,

                  "size": 0,

                  "project_id": project_id,

                  "color": "#00FF33",

                  #"created_by": "roster_user-84fe909f-ba37-48e6-a25f-9d2f129a95b7",

                  "shape": shapes["tag2"]

                })

            # Place edges

            for node in content["nodes"]:

                content["edges"].append({

                    "id": unicode(uuid.uuid1()),

                    "title": "",

                    "description": "",

                    "uri": "",

                    "color": None,

                    "from": notice_id,

                    "to": node["id"],

                    "project_id": project_id,

                    #"created_by": "de68xf75y6hs5rgjhgghxbm217xk"

                })

            response = json.dumps(content)

            return HttpResponse(response, content_type="application/json")

        # If a folder id is set

        folder_id = request.GET.get("folder", "")

        if folder_id!="":

            #TODO : optimize to avoid tag request on each notice

            folder = get_object_or_404(Folder.objects.select_related("datasheets", "datasheets__tags"), pk=folder_id)

            notices = folder.datasheets.all()

            n_tags = []

            notice_tag_dict = {}

            tag_uuid_dict = {}

            for n in notices:

                notice_tag_dict[n.pk] = {"uuid":unicode(uuid.uuid1()), "tags":[] }

                for t in n.tags.all()[:5]:

                    if t.pk not in tag_uuid_dict:

                        tag_uuid_dict[t.pk] = unicode(uuid.uuid1())

                    notice_tag_dict[n.pk]["tags"].append(tag_uuid_dict[t.pk])

                    n_tags.append(t)

            n_tags = [t.pk for t in n_tags]

            all_tags = Tag.objects.filter( pk__in=n_tags ).select_related("dbpedia_fields", "category")

            # Get translated labels

            translations = {}

            if lang not in no_translate_langs:

                transqs = DbpediaFieldsTranslation.objects.filter(master__in = [t.dbpedia_fields if hasattr(t, 'dbpedia_fields') and t.dbpedia_fields else None for t in all_tags], language_code = lang)

                translations = dict([(trans.master_id,trans) for trans in transqs])

            # Prepare Node placer :

            np = CircleNodePlacer()

            if shape=="horiz":

                np = HorLineNodePlacer()

            elif shape=="vert":