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, xml_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

import imghdr

import base64

import cssutils

from os.path import basename

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 = {

                    'view_texts' : get_int(request.GET, 'view_texts',1),

                    'view_comments' : get_int(request.GET, 'view_comments',1),

                    'view_users' : get_int(request.GET, 'view_users',1),

                    }

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

        # 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]

        span = get_among(request.GET, 'span', ('day','month','week',),'week')        

        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" onload="if (window.iframe_onload) iframe_onload();"', None, request.META.get('QUERY_STRING'))

    template_dict = { 'embed_code':embed_code, 'text' : text, 'text_version' : text_version, 'title' : text_version.title}

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

    from cm.models import ApplicationConfiguration

    categories = {}

    for i in range(1, 6):

        if text_version.__dict__['category_' + str(i)] != None and text_version.__dict__['category_' + str(i)] != '':

          categories[i] = text_version.__dict__['category_' + str(i)]

        else:

          if ApplicationConfiguration.get_key('workspace_category_' + str(i)) != None and ApplicationConfiguration.get_key('workspace_category_' + str(i)) != '':

            categories[i] = ApplicationConfiguration.get_key('workspace_category_' + str(i))

    template_dict = {

        'text' : text,

        'text_version' : text_version,

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

        'get_params' : get_params,

        'content' : wrapped_text_version,

        'client_date_fmt' : settings.CLIENT_DATE_FMT,

        'read_only' : read_only,

    }

    template_dict['json_comments'] = jsonize(comments, request)

    template_dict['json_filter_datas'] = jsonize(filter_datas, request)

    if categories:

      categories[0] = 'none'

    template_dict['categories'] = jsonize(categories, request)

    custom_css_str = ApplicationConfiguration.get_key('custom_css')

    if custom_css_str:

      custom_css = cssutils.parseString(custom_css_str)

      for css_rule in custom_css:

        if css_rule.type == css_rule.STYLE_RULE and css_rule.wellformed:

          css_rule.selectorText = "#textcontainer %s" %css_rule.selectorText

      template_dict['custom_css'] = custom_css.cssText

    template_dict['custom_font'] = ApplicationConfiguration.get_key('custom_font')

    template_dict['custom_titles_font'] = ApplicationConfiguration.get_key('custom_titles_font')

    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']

            text = Text.objects.get(key=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_inline_imgs(content, inline=True, full_path=True):

  """

  Replaces (html) links to attachs with embeded inline images

  """

  content = re.sub("%s" %settings.SITE_URL, '', content) # changes absolute urls to relative urls

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

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

  attach_str = r'/attach/%s/'

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

    if match[0]:

      link = attach_str_textversion %match

    else:

      link = attach_str %match[1]

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

    if inline:

      img_fmt = imghdr.what(attach.data.path)

      img = open(attach.data.path, 'rb')

      data = base64.b64encode(img.read())

      img.close()

      content = content.replace(link, 'data:image/'+img_fmt+';base64,'+data)

    else:

      if full_path:

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

      else:

        img_fmt = imghdr.what(attach.data.path)

        content = content.replace(link, match[1]+'.'+img_fmt)

  return content

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

    if format == 'xml':

      return xml_export(request, text_version, whichcomments)