# -*- coding: utf-8 -*-
import copy
from django.db import models
from django.contrib.contenttypes import generic
from django.utils.translation import ugettext_lazy as _
from django.utils import translation
from django.utils.timezone import now
from hvad.models import TranslatableModel, TranslatedFields, TranslationManager
from django.utils.html import strip_tags
from sorl.thumbnail import ImageField
from functions.url_utils import slugify, unique_slug
from functions.model_utils import base_concrete_model
from functions.form_check import translit_with_separator
from django.core.cache import cache


class ArticleManager(TranslationManager):
    cache_time = 60
    def safe_get(self, **kwargs):
        model = self.model
        try:
            return model.objects.get(**kwargs)
        except:
            return None

    def news(self):
        """
        return queryset of news
        """
        model = self.model
        return self.language().filter(type=model.news)

    def blogs(self):
        """
        return queryset of blogs
        """
        model = self.model
        return self.language().filter(type=model.blog)

    def main_page_news(self):
        lang = translation.get_language()
        key = 'main_page_news_%s'%lang
        cached_news = cache.get(key)
        if cached_news:
            return cached_news
        else:
            news = list(self.news().filter(publish_date__isnull=False).order_by('-main_page', '-publish_date', '-modified')[:3])
            cache.set(key, news, self.cache_time)
            return news

    def main_page_blogs(self):
        lang = translation.get_language()
        key = 'main_page_blogs_%s'%lang
        cached_blogs = cache.get(key)
        if cached_blogs:
            return cached_blogs
        else:
            blogs = list(self.blogs().filter(publish_date__isnull=False).order_by('-main_page', '-publish_date')[:3])
            cache.set(key, blogs, self.cache_time)
            return blogs


class Article(TranslatableModel):
    """
    Create Article model

    Uses hvad.TranslatableModel which is child of django.db.models class

    """

    MAX_ON_MAIN_PAGE = 3
    # types of article
    blog = 1
    news = 2

    #set manager of this model
    objects = ArticleManager()
    slug = models.SlugField(unique=True, max_length=255)
    old_id = models.IntegerField(blank=True, null=True)
    logo = ImageField(upload_to='articles_preview', blank=True)
    theme = models.ManyToManyField('theme.Theme')
    blog_theme = models.ManyToManyField('theme.ThemeBlog')
    tag = models.ManyToManyField('theme.Tag', blank=True, null=True)
    author = models.ForeignKey('accounts.User', verbose_name='Автор',
                                  on_delete=models.PROTECT, related_name='articles')
    exposition = models.ForeignKey('exposition.Exposition', blank=True, null=True)
    conference = models.ForeignKey('conference.Conference', blank=True, null=True)
    type = models.PositiveSmallIntegerField(default=1)
    allow_comments = models.BooleanField(default=True)

    # fields that provides features of a visible page on the website
    publish_date = models.DateTimeField(blank=True, null=True)
    expiry_date = models.DateTimeField(_("Expires on"),
        help_text=_("With Published chosen, won't be shown after this time"),
        blank=True, null=True)
    in_sitemap = models.BooleanField(_("Show in sitemap"), default=False)

    # fields that provides features of a visible on main page
    main_page = models.BooleanField(default=False)
    main_page_time = models.DateTimeField(blank=True, null=True)

    # field that check if need generate description
    gen_description = models.BooleanField(_("Generate description"),
        help_text=_("If checked, the description will be automatically "
                    "generated from content. Uncheck if you want to manually "
                    "set a custom description."), default=False)

#    published = models.
    created = models.DateTimeField(auto_now_add=True)
    modified = models.DateTimeField(auto_now=True)

    #translated fields
    translations = TranslatedFields(
        main_title = models.CharField(max_length=255),
        preview = models.TextField(),
        description = models.TextField(blank=False),
        #-----meta
        title = models.CharField(max_length=255, blank=True),
        descriptions = models.CharField(max_length=255, blank=True),
        keywords = models.CharField(max_length=255, blank=True),
    )

    files = generic.GenericRelation('file.FileModel', content_type_field='content_type', object_id_field='object_id')
    class Meta:
        ordering = ['-publish_date']

    def __unicode__(self):
        return self.lazy_translation_getter('main_title', self.pk)

    def translation_model(self):
        return self._meta.translations_model


    def publish(self):
        self.in_sitemap = True
        if not self.publish_date:
            # save time only first time
            self.publish_date = now()
        self.save()

        return self

    def get_event(self):
        if self.exposition:
            return self.exposition
        elif self.conference:
            return self.conference
        return None

    def save(self, *args, **kwargs):
        # If no slug is provided, generates one before saving.
        if not self.slug:
            self.slug = self.generate_unique_slug()
        # Set the description field on save.
        # if self.gen_description:
        #    self.description = strip_tags(self.description_from_content())
        super(Article, self).save(*args, **kwargs)

    def description_from_content(self):
        """
        """
        # place for logic
        return ''

    def generate_unique_slug(self):
        """
        Create a unique slug by passing the result of get_slug() to
        utils.urls.unique_slug, which appends an index if necessary.
        """
        # For custom content types, use the ``Page`` instance for
        # slug lookup.
        concrete_model = base_concrete_model(Article, self)
        slug_qs = concrete_model.objects.exclude(id=self.id)
        slug = unique_slug(slug_qs, "slug", self.get_slug())
        slug = translit_with_separator(slug)
        return slug

    def get_slug(self):
        """
        Allows subclasses to implement their own slug creation logic.
        """
        return slugify(self.get_available_title())

    def get_available_title(self):
        #print self.lazy_translation_getter('main_title', self.pk)
        return u'%s'%self.lazy_translation_getter('main_title', self.pk)

    def _get_next_or_previous_by_publish_date(self, is_next, **kwargs):
        """
        Retrieves next or previous object by publish date. We implement
        our own version instead of Django's so we can hook into the
        published manager and concrete subclasses.
        """
        arg = "publish_date__gt" if is_next else "publish_date__lt"
        order = "publish_date" if is_next else "-publish_date"
        lookup = {arg: self.publish_date}
        concrete_model = base_concrete_model(Article, self)
        try:
            queryset = concrete_model.objects.published
        except AttributeError:
            queryset = concrete_model.objects.all
        try:
            return queryset(**kwargs).filter(**lookup).order_by(order)[0]
        except IndexError:
            pass

    def get_next_by_publish_date(self, **kwargs):
        """
        Retrieves next object by publish date.
        """
        return self._get_next_or_previous_by_publish_date(True, **kwargs)

    def get_previous_by_publish_date(self, **kwargs):
        """
        Retrieves previous object by publish date.
        """
        return self._get_next_or_previous_by_publish_date(False, **kwargs)


    def admin_url(self):
        if self.type == 1:
            return '/admin/article/blog/%s'%self.slug
        elif self.type == 2:
            return '/admin/article/news/%s'%self.slug

    def get_permanent_url(self):
        if self.type == 1:
            return '/blogs/%s/'%self.slug
        elif self.type == 2:
            return '/news/%s/'%self.slug

    def get_blog_preview(self):

        preview = self.files.filter(purpose='preview')
        if preview:
            return preview[0]
        else:
            return None

    def get_blog_preview2(self):

        preview = self.files.filter(purpose='preview2')
        if preview:
            return preview[0]
        else:
            return None

    def get_catalog(self):
        if self.type == 1:
            return '/blogs/'
        elif self.type == 2:
            return '/news/'

    def similar(self):
        themes = [item ['id'] for item in self.theme.all().values('id')]
        return list(Article.objects.language().exclude(id=self.id).filter(type=self.type, publish_date__isnull=False, theme__in=themes).distinct().order_by('-publish_date')[:3])


from django.db.models.signals import post_save
from functions.signal_handlers import post_save_handler


post_save.connect(post_save_handler, sender=Article)