from cm.utils.embed import embed_html

from cm.activity import register_activity

from cm.client import jsonize, get_filter_datas, edit_comment, remove_comment, \

    add_comment, RequestComplexEncoder, comments_thread, own_notify

from cm.cm_settings import NEW_TEXT_VERSION_ON_EDIT

from cm.exception import UnauthorizedException

from cm.message import *

from cm.models import *

from django.forms.util import ErrorList

from cm.models_base import generate_key

from cm.security import get_texts_with_perm, has_perm, get_viewable_comments, \

    has_perm_on_text

from cm.utils import get_among, get_among, get_int

from cm.utils.html import on_content_receive

from cm.utils.comment_positioning import compute_new_comment_positions, \

    insert_comment_markers

from cm.utils.spannifier import spannify

from cm.views import get_keys_from_dict, get_textversion_by_keys_or_404, get_text_by_keys_or_404, redirect

from cm.views.export import content_export2, content_export

from cm.views.user import AnonUserRoleForm, cm_login

from difflib import unified_diff

from django import forms

from django.conf import settings

from django.contrib.auth import login as django_login

from django.contrib.auth.forms import AuthenticationForm

from django.contrib.auth.models import User

from django.core.urlresolvers import reverse

from django.db.models import Q

from django.forms import ModelForm

from django.forms.models import BaseModelFormSet, modelformset_factory

from django.http import HttpResponse, HttpResponseRedirect, Http404

from django.shortcuts import render_to_response

from django.template import RequestContext

from django.template.loader import render_to_string

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

from django.views.generic.list_detail import object_list

from tagging.models import Tag

import difflib

import logging

import mimetypes

import simplejson

import sys

import re

from django.db.models.sql.datastructures import EmptyResultSet

def get_text_and_admin(key, adminkey, assert_admin = False):

    """

    assert_admin => redirect to unauthorized if not admin 

    """

    admin = False

    if adminkey:

        text = Text.objects.get(key = key, adminkey = adminkey)

        if text:

            admin = True

    else:

        text = Text.objects.get(key=key)

    if assert_admin and not admin:

        raise UnauthorizedException('Is not admin')        

    return text, admin

ACTIVITY_PAGINATION = 10

RECENT_TEXT_NB = 5

RECENT_COMMENT_NB = RECENT_TEXT_NB

MODERATE_NB = 5

def dashboard(request):

    request.session.set_test_cookie()

    if request.user.is_authenticated():

        act_view = {

                    }

        # texts with can_view_unapproved_comment perms

        moderator_texts = get_texts_with_perm(request, 'can_view_unapproved_comment')

        viewer_texts = get_texts_with_perm(request, 'can_view_approved_comment')

        all_texts_ids = [t.id for t in moderator_texts] + [t.id for t in viewer_texts]

        template_dict = { 

                         'span' : span,

                         'last_texts' : get_texts_with_perm(request, 'can_view_text').order_by('-modified')[:RECENT_TEXT_NB],

                         'last_comments' : Comment.objects.filter(text_version__text__in=all_texts_ids).order_by('-created')[:RECENT_COMMENT_NB],# TODO: useful?

                         #'last_users' : User.objects.all().order_by('-date_joined')[:5],

                         }

        template_dict.update(act_view)

        all_activities = {

                               'view_comments' : ['comment_created','comment_removed'],

                               'view_users' : ['user_created', 'user_activated', 'user_suspended','user_enabled',],

                               'view_texts' : ['text_created','text_removed', 'text_edited', 'text_edited_new_version'],

                               }

        selected_activities = []

        [selected_activities.extend(all_activities[k]) for k in act_view.keys() if act_view[k]]

        activities = Activity.objects.filter(type__in = selected_activities)

        if not has_perm(request,'can_manage_workspace'):

            texts = get_texts_with_perm(request, 'can_view_text')

            activities = activities.filter(Q(text__in=texts))

            comments = [] 

            [comments.extend(get_viewable_comments(request, t.last_text_version.comment_set.all(), t)) for t in texts]

            activities = activities.filter(Q(comment__in=comments) | Q(comment=None) )

            template_dict['to_mod_profiles'] = []

        else:

            template_dict['to_mod_profiles'] = UserProfile.objects.filter(user__is_active=False).filter(is_suspended=True).order_by('-user__date_joined')[:MODERATE_NB]

        template_dict['to_mod_comments'] = Comment.objects.filter(state='pending').filter(text_version__text__in=moderator_texts).order_by('-modified')[:MODERATE_NB-len(template_dict['to_mod_profiles'])]

        activities = activities.order_by('-created')

        return object_list(request, activities,

                           template_name = 'site/dashboard.html',

                           paginate_by = paginate_by,

                           extra_context = template_dict,

                           )

    else:

        if request.method == 'POST':

            form = AuthenticationForm(request, request.POST)

            if form.is_valid():

                user = form.get_user()

                user.backend = 'django.contrib.auth.backends.ModelBackend'

                cm_login(request, user)            

                display_message(request, _(u"You're logged in!"))

                return HttpResponseRedirect(reverse('index'))

        else:

            form = AuthenticationForm()        

        public_texts = get_texts_with_perm(request, 'can_view_text').order_by('-modified')

        template_dict = {

                         'form' : form,

                         'texts' : public_texts,

                         }

        return render_to_response('site/non_authenticated_index.html', template_dict, context_instance=RequestContext(request))

TEXT_PAGINATION = 10

# security check inside view

# TODO: set global access perm

def text_list(request):

    paginate_by = get_int(request.GET,'paginate',TEXT_PAGINATION)

    tag_selected = request.GET.get('tag_selected', 0)

    order_by = get_among(request.GET,'order',('title','author','modified','-title','-author','-modified'),'-modified')

    if request.method == 'POST':

        action = request.POST.get('action',None)

        text_keys = get_keys_from_dict(request.POST, 'check-').keys()        

        if action == 'delete':

            for text_key in text_keys:

                text = Text.objects.get(key=text_key)

                if has_perm(request, 'can_delete_text', text=text):

                    text.delete()

                else:

                    raise UnauthorizedException('No perm can_delete_text on comment') 

            display_message(request, _(u'%(nb_texts)i text(s) deleted') %{'nb_texts':len(text_keys)})

            return HttpResponseRedirect(reverse('text'))

    texts = get_texts_with_perm(request, 'can_view_text').order_by(order_by)

    try:

        tag_list = Tag.objects.usage_for_queryset(TextVersion.objects.filter(id__in = [t.last_text_version_id for t in get_texts_with_perm(request, 'can_view_text')]))

    except EmptyResultSet:

        tag_list = []

    context = {    

               'tag_list' : tag_list,

               'tag_selected': tag_selected,

               }

    if tag_selected:     

        tag_ids = Tag.objects.filter(name=tag_selected)

        if tag_ids:   

            content_type_id = ContentType.objects.get_for_model(TextVersion).pk

            # table cm_userprofile is not present if display_suspended_users: fix this 

            texts = texts.extra(where=['tagging_taggeditem.object_id = cm_text.last_text_version_id', 

                                       'tagging_taggeditem.content_type_id = %i' %content_type_id,

                                       'tagging_taggeditem.tag_id = %i' %tag_ids[0].id],

                                tables=['tagging_taggeditem'],

                                )

    return object_list(request, texts,

                       template_name = 'site/text_list.html',

                       paginate_by = paginate_by,

                       extra_context=context,

                       )

@has_perm_on_text('can_view_text')

def text_view(request, key, adminkey=None):

    text = get_text_by_keys_or_404(key)

    register_activity(request, "text_view", text=text)    

    text_version = text.get_latest_version()

    embed_code = embed_html(key, 'id="text_view_frame" name="text_view_frame"', None, request.META.get('QUERY_STRING'))

    template_dict = { 'embed_code':embed_code, 'text' : text, 'text_version' : text_version, 'title' : text_version.title, 'content' : text_version.get_content()}

    return render_to_response('site/text_view.html', template_dict, context_instance=RequestContext(request))

@has_perm_on_text('can_delete_text')

def text_delete(request, key):

    text = Text.objects.get(key=key)

    if request.method != 'POST':

        raise UnauthorizedException('Unauthorized')

    display_message(request, _(u'Text %(text_title)s deleted') %{'text_title':text.title})

    register_activity(request, "text_removed", text=text)    

    text.delete()

    return HttpResponse('') # no redirect because this is called by js

@has_perm_on_text('can_delete_text')

def text_version_delete(request, key, text_version_key):

    text_version = TextVersion.objects.get(key=text_version_key)

    text=text_version.text

    if request.method != 'POST':

        raise UnauthorizedException('Unauthorized')

    display_message(request, _(u'Text version %(text_version_title)s deleted') %{'text_version_title':text_version.title})

    register_activity(request, "text_version_removed", text=text)

    text_version.delete()

    return HttpResponse('') # no redirect because this is called by js

@has_perm_on_text('can_view_text') # only protected by text_view / comment filtering done in view

def text_view_comments(request, key, version_key=None, adminkey=None):

    text = get_text_by_keys_or_404(key)

    read_only = False

    if version_key :

        text_version = get_textversion_by_keys_or_404(version_key, adminkey, key)

        if settings.ALLOW_CLIENT_MODIF_ON_LAST_VERSION_ONLY :

            read_only = (text.last_text_version_id != text_version.id) 

    else :

        text_version = text.get_latest_version()

    comments = get_viewable_comments(request, text_version.comment_set.filter(reply_to__isnull=True),text)

    filter_datas = get_filter_datas(request, text_version, text)

    get_params = simplejson.dumps(request.GET)

    wrapped_text_version, _ , _ = spannify(text_version.get_content())

    template_dict = {'text' : text,

                               'text_version' : text_version,

                               'title' : text_version.title, # TODO use it ...

                               'get_params' : get_params,

                               'json_comments':jsonize(comments, request),

                               'json_filter_datas':jsonize(filter_datas, request),

                               'content' : wrapped_text_version,

                               'client_date_fmt' : settings.CLIENT_DATE_FMT,

                               'read_only' : read_only,

                               }

    return render_to_response('site/text_view_comments.html',

                              template_dict,

                              context_instance=RequestContext(request))

def client_exchange(request):

    ret = None

    if request.method == 'POST' :

        function_name = request.POST['fun']# function called from client

        user = request.user

        if function_name == 'experiment' :

            ret = experiment()

        elif function_name == 'warn' :

            # TODO: (RBE to RBA) send mail withinfos

            ret = "warn test"

            #print request.POST

        else :

            key = request.POST['key']

            version_key = request.POST['version_key']

            #TODO: stupid why restrict to latest ? 

            text_version = text.get_latest_version()

            if (text != None) :

                if function_name == 'ownNotify' : 

                    ret = own_notify(request=request, key=key)

                if function_name in ('editComment', 'addComment', 'removeComment',) :

                    if function_name == 'editComment' :

                        ret = edit_comment(request=request, key=key, comment_key=request.POST['comment_key'])

                    elif function_name == 'addComment' :

                        ret = add_comment(request=request, key=key, version_key=version_key)

                    elif function_name == 'removeComment' :

                        ret = remove_comment(request=request, key=key, comment_key=request.POST['comment_key'])

                    ret['filterData'] = get_filter_datas(request, text_version, text)

                    #ret['tagCloud'] = get_tagcloud(key)

    if ret :

        if type(ret) != HttpResponseRedirect and type(ret) != HttpResponse:

            ret = HttpResponse(simplejson.dumps(ret, cls=RequestComplexEncoder, request=request))        

    else :

        ret = HttpResponse()

        ret.status_code = 403 

    return ret 

def from_html_links_to_abs_links(content):

    """

    Replaces (html) links to attachs with real file path on server

    """

    attach_re = r'/text/(?P<key>\w*)/attach/(?P<attach_key>\w*)/'

    attach_str = r'/text/%s/attach/%s/'

    for match in re.findall(attach_re, content):

        link = attach_str %match

        attach = Attachment.objects.get(key=match[1], text_version__text__key=match[0])                

        content = content.replace(link, attach.data.path)

    return content

#NOTE : some arguments like : withcolor = "yes" + format = "markdown" are incompatible

#http://localhost:8000/text/text_key_1/export/pdf/1/all/1

def text_export(request, key, format, download, whichcomments, withcolor, adminkey=None):

    text, admin = get_text_and_admin(key, adminkey)

    text_version = text.get_latest_version()

    original_content = text_version.content

    original_format = text_version.format # BD : html or markdown for  now ...

    download_response = download == "1"

    with_color = withcolor == "1"

    comments = [] # whichcomments=="none"

    if whichcomments == "filtered" or whichcomments == "all":

        #comments = text_version.comment_set.filter(reply_to__isnull=True)# whichcomments=="all"

        #comments = get_viewable_comments(request, text_version.comment_set.filter(reply_to__isnull=True), text, order_by=('start_wrapper','start_offset','end_wrapper','end_offset'))# whichcomments=="all"

        _comments = text_version.comment_set.all()

        if whichcomments == "filtered" :

            filteredIds = []

            if request.method == 'POST' :

                ll = request.POST.get('filteredIds',[]).split(",")

                filteredIds = [ int(l) for l in ll if l]

            _comments = text_version.comment_set.filter(id__in=filteredIds) # security ! TODO CROSS PERMISSIONS WITH POST CONTENT

        comments = get_viewable_comments(request, _comments, text, order_by=('start_wrapper','start_offset','end_wrapper','end_offset'))# whichcomments=="all"

    # decide to use pandoc or not

    if with_color :

        use_pandoc = False  # pandoc wouldn't preserve comments scope background colors

    else :

        if format in ('markdown', 'latex') : 

            use_pandoc = True

        elif format in ('pdf', 'odt') : 

            use_pandoc = (original_format == "markdown")

        elif format in ('doc', 'html') :

            use_pandoc = False

    # correct attach path => real path

    if format in ('pdf','odt') :        

        original_content = from_html_links_to_abs_links(original_content)

    if len(comments) == 0 : #want to bypass html conversion in this case

        return content_export2(request, original_content, text_version.title, original_format, format, use_pandoc, download_response)

    else : # case comments to be added  

        #comments = comments.order_by('start_wrapper','start_offset','end_wrapper','end_offset')

        html = pandoc_convert(original_content, original_format, 'html')

        wrapped_text_version, _ , _ = spannify(html)

        with_markers = True

        marked_content = insert_comment_markers(wrapped_text_version, comments, with_markers, with_color)

        viewable_comments = comments_thread(request, text_version, text) 

    #        viewable_commentsnoreply = get_viewable_comments(request, commentsnoreply, text, order_by = ('start_wrapper','start_offset','end_wrapper','end_offset'))

    #        viewable_comments = []

    #        for cc in viewable_commentsnoreply :

    #            viewable_comments += list_viewable_comments(request, [cc], text)

        # numerotation{  id --> numbered as a child}

        extended_comments = {}

        nb_children = {}