import re

from cm.converters.pandoc_converters import \

    CHOICES_INPUT_FORMATS as CHOICES_INPUT_FORMATS_PANDOC, \

    DEFAULT_INPUT_FORMAT as DEFAULT_INPUT_FORMAT_PANDOC, pandoc_convert

from cm.models_base import PermanentModel, KeyManager, Manager, KeyModel, AuthorModel

from cm.models_utils import *

from cm.utils.dj import absolute_reverse

from cm.utils.date import datetime_to_user_str

from cm.utils.html import on_content_receive

from cm.utils.comment_positioning import compute_new_comment_positions

from django import forms

from django.db.models import Q

from django.template.loader import render_to_string

from django.conf import settings

from django.template import RequestContext

from django.contrib.auth.models import Permission

from django.contrib.contenttypes import generic

from django.contrib.contenttypes.models import ContentType

from django.core.files.base import ContentFile

from django.core.urlresolvers import reverse

from django.template.defaultfilters import timesince

from django.db import models

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

from tagging.fields import TagField

import pickle

from django.db import connection

from datetime import datetime

class TextManager(Manager):

    def create_text(self, title, format, content, note, name, email, tags, user=None, state='approved', **kwargs):

        content = on_content_receive(content, format)

        text = self.create(name=name, email=email, user=user, state=state)

        text_version = TextVersion.objects.create(title=title, format=format, content=content, text=text, note=note, name=name, email=email, tags=tags, user=user)

        return text

    def create_new_version(self, text, title, format, content, note, name, email, tags, user=None, **kwargs):

        text_version = TextVersion.objects.create(title=title, format=format, content=content, text=text, note=note, name=name, email=email, tags=tags, user=user)

        return text_version

class Text(PermanentModel, AuthorModel):

    modified = models.DateTimeField(auto_now=True)

    created = models.DateTimeField(auto_now_add=True)

    private_feed_key = models.CharField(max_length=20, db_index=True, unique=True, blank=True, null=True, default=None)

    # denormalized fields

    last_text_version = models.ForeignKey("TextVersion", related_name='related_text', null=True, blank=True)

    title = models.TextField()

    objects = TextManager()

    def get_latest_version(self):

        return self.last_text_version

    def fetch_latest_version(self):

        versions = self.get_versions()

        if versions:

            return versions[0]

        else:

            return None

    def update_denorm_fields(self):

        real_last_text_version = self.fetch_latest_version()

        try:

            last_text_version = self.last_text_version

        except TextVersion.DoesNotExist:

            # the text version has just been deleted

            last_text_version = None

        modif = False

        if real_last_text_version and real_last_text_version != last_text_version:

            self.last_text_version = real_last_text_version

            modif = True

        if real_last_text_version and real_last_text_version.title and real_last_text_version.title != self.title:

            self.title = real_last_text_version.title

            modif = True

        if real_last_text_version and real_last_text_version.modified != self.modified:

            self.modified = real_last_text_version.modified

            modif = True

        if modif:

            self.save()

    def get_title(self):

        return self.get_latest_version().title

    def get_versions(self):

        """

        Versions with most recent first

        """

        versions = TextVersion.objects.filter(text__exact=self).order_by('-created')

        # TODO: use new postgresql 8.4 row_number as extra select to do that

        #for index in xrange(len(versions)):

        #    v = versions[index]

        #    # version_number is 1-based

        #    setattr(v, 'version_number', len(versions) - index)

        return versions

    def get_version(self, version_number):        

        """

        Get version number 'version_number' (1-based)

        """

        version = TextVersion.objects.filter(text__exact=self).order_by('created')[version_number - 1:version_number][0]

        return version

    def get_inversed_versions(self):

        versions = TextVersion.objects.filter(text__exact=self).order_by('created')

        # TODO: use new postgresql 8.4 row_number as extra select to do that

        #for index in xrange(len(versions)):

        #    v = versions[index]

        #    # version_number is 1-based

        #    setattr(v, 'version_number', index + 1)

        return versions

    def get_versions_number(self):

        return self.get_versions().count()

    def is_admin(self, adminkey=None):

        if adminkey and self.adminkey == adminkey:

            return True

        else:

            return False

    def revert_to_version(self, text_version_key):

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

        if text_version.text != self:

            raise Exception('Invalid revert attempt')

        new_text_version = TextVersion.objects.duplicate(text_version, True)

        return new_text_version

    def edit(self, new_title, new_format, new_content, new_tags=None, new_note=None, keep_comments=True, cancel_modified_scopes=True, new_version=True):

        text_version = self.get_latest_version()

        if new_version:        

            text_version = TextVersion.objects.duplicate(text_version, keep_comments)

        text_version.edit(new_title, new_format, new_content, new_tags, new_note, keep_comments, cancel_modified_scopes)        

        return text_version 

    def __unicode__(self):

        return self.title    

DEFAULT_INPUT_FORMAT = getattr(settings, 'DEFAULT_INPUT_FORMAT', DEFAULT_INPUT_FORMAT_PANDOC)

CHOICES_INPUT_FORMATS = getattr(settings, 'CHOICES_INPUT_FORMATS', CHOICES_INPUT_FORMATS_PANDOC)

class TextVersionManager(KeyManager):

    def duplicate(self, text_version, duplicate_comments=True):

        #import pdb;pdb.set_trace()

        old_comment_set = set(text_version.comment_set.all())

        text_version.id = None

        # generate new key

        text_version.key = self._gen_key()

        text_version.adminkey = self._gen_adminkey()

        text_version.save()

        duplicate_text_version = text_version

        if duplicate_comments:

            old_comment_map = {}

            while len(old_comment_set):

                for c in old_comment_set:

                    if not c.reply_to or c.reply_to.id in old_comment_map:

                        old_id = c.id

                        old_comment_set.remove(c)

                        reply_to = None

                        if c.reply_to:                            

                            reply_to = old_comment_map[c.reply_to.id]  

                        c2 = Comment.objects.duplicate(c, duplicate_text_version, reply_to, keep_dates=True)

                        old_comment_map[old_id] = c2

                        break

        return duplicate_text_version

class TextVersion(AuthorModel, KeyModel):

    modified = models.DateTimeField(auto_now=True)

    created = models.DateTimeField(auto_now_add=True)

    title = models.TextField(ugettext_lazy("Title"))

    format = models.CharField(ugettext_lazy("Format"), max_length=20, blank=False, default=DEFAULT_INPUT_FORMAT, choices=CHOICES_INPUT_FORMATS)

    content = models.TextField(ugettext_lazy("Content"))

    tags = TagField(ugettext_lazy("Tags"), max_length=1000)

    note = models.CharField(ugettext_lazy("Note"), max_length=100, null=True, blank=True)

    mod_posteriori = models.BooleanField(ugettext_lazy('Moderation a posteriori?'), default=True)

    text = models.ForeignKey("Text")

    objects = TextVersionManager()

    def get_content(self, format='html'):

        return pandoc_convert(self.content, self.format, format)

#    def _get_comments(self, user = None, filter_reply = 0):        

#        """

#        get comments viewable by this user (user = None or user = AnonymousUser => everyone)

#        filter_reply = 0: comments and replies

#                       1: comments

#                       2: replies

#        """        

#        from cm.security import has_perm_on_text # should stay here to avoid circular dependencies

#        

#        if has_perm(user, 'can_view_unapproved_comment', self.text):

#            comments = self.comment_set.all()

#        elif has_perm(user, 'can_view_approved_comment', self.text):

#            comments = self.comment_set.filter(visible=True)

#        elif has_perm(user, 'can_view_comment_own', self.text):

#            comments = self.comment_set.filter(user=user)

#        else:

#            return Comment.objects.none() # empty queryset

#        if filter_reply:

#            comments = comments.filter)

#        return comments

#

#    def get_comments_as_json(self, user = None):

#        return simplejson.dumps(self._get_comments(user, filter_reply=0))

#

#    def get_comments_and_replies(self, user = None):

#        return (self.get_comments(user),

#                self.get_replies(user))

#

    def get_comments(self):

        "Warning: data access without security"

        return self.comment_set.filter(reply_to=None, deleted=False)

    def get_replies(self):

        "Warning: data access without security"

        return self.comment_set.filter(~Q(reply_to == None), Q(deleted=False))

    def __unicode__(self):

        return '<%d> %s' % (self.id, self.title)    

    def edit(self, new_title, new_format, new_content, new_tags=None, new_note=None, keep_comments=True, cancel_modified_scopes=True):

        new_content = on_content_receive(new_content, new_format) 

        if not keep_comments :

            self.comment_set.all().delete()

        elif self.content != new_content or new_format != self.format:

            comments = self.get_comments() ;

            tomodify_comments, toremove_comments = compute_new_comment_positions(self.content, self.format, new_content, new_format, comments)

            #print "tomodify_comments"

            #print tomodify_comments

            #print "toremove_comments",len(toremove_comments)

            [comment.save(keep_dates=True) for comment in tomodify_comments]

            if cancel_modified_scopes :

                [comment.remove_scope() for comment in toremove_comments]

            else :

                [comment.delete() for comment in toremove_comments]

        self.title = new_title

        if new_tags:

            self.tags = new_tags

        if new_note:

            self.note = new_note

        self.content = new_content

        self.format = new_format

        self.save()

    def get_next_version(self):        

        other_versions = TextVersion.objects.filter(text__exact=self.text).order_by('created').filter(created__gt=self.created)

        return other_versions[0] if other_versions else None 

        if other_versions:

            return 

        else:

            return None

    def get_previous_version(self):

        other_versions = TextVersion.objects.filter(text__exact=self.text).order_by('-created').filter(created__lt=self.created)

        return other_versions[0] if other_versions else None

    def get_version_number(self):

        return TextVersion.objects.filter(text__exact=self.text).order_by('created').filter(created__lte=self.created).count()

class CommentManager(Manager):

    def duplicate(self, comment, text_version, reply_to=None, keep_dates=False):

        comment.id = None

        comment.text_version = text_version

        if reply_to:

            comment.reply_to = reply_to

        self.update_keys(comment)

        comment.save(keep_dates=keep_dates)

        return comment

from cm.models_base import KEY_MAX_SIZE, generate_key

class Comment(PermanentModel, AuthorModel):

    modified = models.DateTimeField()

    created = models.DateTimeField()

    # key to identify same comments across versions

    id_key = models.CharField(max_length=KEY_MAX_SIZE, db_index=True, default=generate_key)

    text_version = models.ForeignKey("TextVersion")

    # comment_set will be replies

    reply_to = models.ForeignKey("Comment", null=True, blank=True)

    title = models.TextField()

    content = models.TextField()

    content_html = models.TextField()

    format = models.CharField(_("Format:"), max_length=20, blank=False, default=DEFAULT_INPUT_FORMAT, choices=CHOICES_INPUT_FORMATS)

    tags = TagField()

    start_wrapper = models.IntegerField(null=True, blank=True)

    end_wrapper = models.IntegerField(null=True, blank=True)

    start_offset = models.IntegerField(null=True, blank=True)

    end_offset = models.IntegerField(null=True, blank=True)

    objects = CommentManager()

    def save(self, keep_dates=False, **kwargs):

        if not keep_dates:

            now = datetime.now()

            if not self.id: 

                self.created = now  

            self.modified = now 

        super(PermanentModel, self).save(**kwargs) 

    def __unicode__(self):

        return '<%d> %s [st_wrp:%s, st_ofs:%s, e_wrp:%s, e_ofs:%s]' % (self.id, self.title,  self.start_wrapper ,  self.start_offset,  self.end_wrapper,  self.end_offset, )    

    def is_reply(self):

        return self.reply_to != None

    def is_thread_full_visible(self, own_user=None):

        """

        own_user: comment belonging to this user are also visible 

        """

        if self.state == 'approved' or (own_user and self.user == own_user):

            if self.reply_to==None:

                return True

            else:                

                return self.reply_to.is_thread_full_visible(own_user)

        return False

    def is_scope_removed(self):

        #when scope is "removed" we will have 

        #self.start_wrapper == self.end_wrapper == self.start_offset == self.end_offset == -1

        return (self.start_wrapper == -1)  

    def top_comment(self):

        if self.reply_to == None :

            return self

        else : 

            return self.reply_to.top_comment()

    def depth(self):

        if self.reply_to == None :

            return 0

        else : 

            return 1 + self.reply_to.depth()

    def delete(self):

        PermanentModel.delete(self)

        # delete replies

        [c.delete() for c in self.comment_set.all()]

    def remove_scope(self):

        self.start_wrapper = self.end_wrapper = self.start_offset = self.end_offset = -1

        self.save()

# http://docs.djangoproject.com/en/dev/topics/files/#topics-files

# default conf values

DEFAULT_CONF = {

                'workspace_name' : 'Workspace',

                'site_url' : settings.SITE_URL,

                'email_from' : settings.DEFAULT_FROM_EMAIL,

                }

from cm.role_models import change_role_model

class ConfigurationManager(models.Manager):

    def set_workspace_name(self, workspace_name):