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.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

class TextManager(Manager):

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

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

        modif = False

        if real_last_text_version and real_last_text_version != self.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)

        #for v in versions:

        #    print v.created,v.id,v.version_number

        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, v_id):

        text_version = self.get_version(int(v_id))

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

        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(models.Manager):

    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

        #import pdb;pdb.set_trace()

        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)

                        old_comment_map[old_id] = c2

                        break

        return duplicate_text_version

class TextVersion(AuthorModel):

    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'):

        converted_content = pandoc_convert(self.content, self.format, format)

        return converted_content 

#    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): # TODO : tags

        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",len(tomodify_comments)

            #print "toremove_comments",len(toremove_comments)

            [comment.save() for comment in tomodify_comments]

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

class CommentManager(Manager):

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

        comment.id = None

        comment.text_version = text_version

        if reply_to:

            comment.reply_to = reply_to

        self.update_keys(comment)

        comment.save()

        return comment

class Comment(PermanentModel, AuthorModel):

    modified = models.DateTimeField(auto_now=True)

    created = models.DateTimeField(auto_now_add=True)

    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 __unicode__(self):

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

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

# 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):

        if workspace_name and not self.get_key('workspace_name')!=u'Workspace':

            self.set_key('workspace_name', _(u"%(workspace_name)s's workspace") %{'workspace_name':workspace_name})

    def get_key(self, key, default_value=None):

        try:

            return self.get(key=key).value

        except Configuration.DoesNotExist:

            return DEFAULT_CONF.get(key, default_value)

    def set_key(self, key, value):

        conf, created = self.get_or_create(key=key)

        if created or conf.value != value:

            conf.value = value

            conf.save()

            if key == 'workspace_role_model':

                change_role_model(value)

    def __getitem__(self, key):

        return self.get_key(key, None)

import base64

class Configuration(models.Model):

    key = models.TextField(blank=False) # , unique=True cannot be added: creates error on mysql (?)

    raw_value = models.TextField(blank=False)

    def get_value(self):

        return pickle.loads(base64.b64decode(self.raw_value.encode('utf8')))

    def set_value(self, value):        

        self.raw_value = base64.b64encode(pickle.dumps(value, 0)).encode('utf8')

    value = property(get_value, set_value)

    objects = ConfigurationManager()

    def __unicode__(self):

        return '%s: %s' % (self.key, self.value)    

ApplicationConfiguration = Configuration.objects     

class AttachmentManager(KeyManager):

    def create_attachment(self, text_version, filename, data):

        attach = self.create(text_version=text_version)

        ff = ContentFile(data)

        attach.data.save(filename, ff)

        return attach

class Attachment(KeyModel):

    data = models.FileField(upload_to="attachments/%Y/%m/%d/", max_length=1000)

    text_version = models.ForeignKey(TextVersion)

    objects = AttachmentManager()

class NotificationManager(KeyManager):

    def create_notification(self, text, type, active, email_or_user):

        notification = self.create(text=text, type=type, active=active)

        notification.set_email_or_user(email_or_user)

        return notification