from django.db import models, transaction

from django.conf import settings

from django.contrib.auth.models import User

from django.contrib.contenttypes.fields import GenericRelation

from django.contrib.contenttypes.models import ContentType

from django_comments_xtd.models import XtdComment

from django.utils.text import slugify

import iconolab.signals.handlers as iconolab_signals

import uuid, json, re, requests, urllib, logging

logger = logging.getLogger(__name__)

class Collection(models.Model):

    """

        Collection objects are the thematic item repositories in Iconolab

            name: the name displayed in the url and also used to identify the collection

            verbose_name: the name displayed in the text of the pages

            description: the short description of the collection that will be displayed by default in pages

            complete_description: the complete description that will be shown with a "view more" button/link

            image/height/width: the collection image that will be shown in the collection description

            show_image_on_home: if True, the collection will appear by default on the homepage as one of the bigger images

    """

    name = models.SlugField(max_length=50, unique=True)

    verbose_name = models.CharField(max_length=50, null=True, blank=True)

    description = models.TextField(null=True, blank=True, default="")

    complete_description = models.TextField(null=True, blank=True, default="")

    image = models.ImageField(upload_to='uploads/', height_field='height', width_field='width', null=True, blank=True)

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

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

    show_image_on_home = models.BooleanField(default=False)

    def __str__(self):

        return self.name

class Item(models.Model):

    """

        Item objects belong to a collection, are linked to a metadata item, and to one or more images

    """

    collection = models.ForeignKey(Collection, related_name="items")

    item_guid = models.UUIDField(default=uuid.uuid4, editable=False)

    def __str__(self):

        return str(self.item_guid)+":from:"+self.collection.name

    @property

    def images_sorted_by_name(self):

        return self.images.order_by("-name").all()

class ItemMetadata(models.Model):

    """

        Metadata object for the item class. Each field represents what we can import from the provided .csv files 

    """

    item = models.OneToOneField('Item', related_name='metadatas')

    authors = models.CharField(max_length=255, default="")

    school = models.CharField(max_length=255, default="")

    field = models.CharField(max_length=255, default="")

    designation = models.CharField(max_length=255, default="")

    datation = models.CharField(max_length=255, default="")

    technics = models.CharField(max_length=255, default="")

    measurements = models.CharField(max_length=255, default="")

    create_or_usage_location = models.CharField(max_length=255, default="")

    discovery_context = models.CharField(max_length=255, default="")

    conservation_location = models.CharField(max_length=255, default="")

    photo_credits = models.CharField(max_length=255, default="")

    inventory_number = models.CharField(max_length=255, default="")

    joconde_ref = models.CharField(max_length=255, default="")

    @property

    def get_joconde_url(self):

        return settings.JOCONDE_NOTICE_BASE_URL+self.joconde_ref.rjust(11, '0')

    def __str__(self):

        return "metadatas:for:"+str(self.item.item_guid)

class Image(models.Model):

    """

        Each image object is linked to one item, users can create annotations on images

    """

    image_guid = models.UUIDField(default=uuid.uuid4, editable=False)

    name = models.CharField(max_length=200)

    media = models.ImageField(upload_to='uploads/', height_field='height', width_field='width')

    item = models.ForeignKey('Item', related_name='images', null=True, blank=True)

    height = models.IntegerField(null=False, blank=False)

    width = models.IntegerField(null=False, blank=False)

    created = models.DateTimeField(auto_now_add=True, null=True)

    def __str__(self):

        return str(self.image_guid)+":"+self.name

    @property

    def wh_ratio(self):

        return self.width / self.height

    @property

    def collection(self):

        return self.item.collection.name

    @property

    def title(self):

        return self.item.metadatas.designation

    @property

    def authors(self):

        return self.item.metadatas.authors

    @property

    def school(self):

        return self.item.metadatas.school

    @property

    def designation(self):

        return self.item.metadatas.designation

    @property

    def datation(self):

        return self.item.metadatas.datation

    @property

    def technics(self):

        return self.item.metadatas.technics

    @property

    def measurements(self):

        return self.item.metadatas.measurements

    @property

    def tag_labels(self):

        tag_list = []

        for annotation in self.annotations.all():

            revision_tags = json.loads(annotation.current_revision.get_tags_json())

            tag_list += [tag_infos['tag_label'] for tag_infos in revision_tags if tag_infos.get('tag_label') is not None] #deal with

        return tag_list

class ImageStats(models.Model):

    """

        Stats objects for a given image, keep count of several values to be displayed in image and item pages

    """

    image = models.OneToOneField('Image', related_name='stats', blank=False, null=False)

    views_count = models.IntegerField(blank=True, null=True, default=0)

    annotations_count = models.IntegerField(blank=True, null=True, default=0)

    submitted_revisions_count = models.IntegerField(blank=True, null=True, default=0)

    comments_count = models.IntegerField(blank=True, null=True, default=0)

    folders_inclusion_count = models.IntegerField(blank=True, null=True, default=0)

    tag_count = models.IntegerField(blank=True, null=True, default=0)

    def __str__(self):

        return "stats:for:"+str(self.image.image_guid)

    def set_tags_stats(self):

        self.tag_count = Tag.objects.filter(tagginginfo__revision__annotation__image = self.image).distinct().count()

    @transaction.atomic

    def update_stats(self):

        self.annotations_count = 0

        self.submitted_revisions_count = 0

        self.comments_count = 0

        image_annotations = Annotation.objects.filter(image=self.image)

        # views_count - Can't do much about views count

        # annotations_count

        self.annotations_count = image_annotations.count()

        # submitted_revisions_count & comment_count

        for annotation in image_annotations.all():

            annotation_revisions = annotation.revisions

            self.submitted_revisions_count += annotation_revisions.count()

            self.comments_count += XtdComment.objects.for_app_models("iconolab.annotation").filter(

                object_pk = annotation.pk,

            ).count()

        # tag_count

        self.tag_count = Tag.objects.filter(tagginginfo__revision__annotation__image = self.image).distinct().count()

        self.save()

class AnnotationManager(models.Manager):

    """

        Manager class for annotation, it handles annotation creation (with initial revision creation, and 

        has methods to get a list of annotation commented for a given user, and a list of annotations contributed for a

        given user

    """

    @transaction.atomic

    def create_annotation(self, author, image, title='', description='', fragment='', tags_json='[]'):

        """

            Creates a new Annotation with its associated AnnotationStats and initial AnnotationRevision

        """

        # Create annotation object

        new_annotation = Annotation(

            image=image, 

            author=author

        )

        new_annotation.save()

        # Create initial revision

        initial_revision = AnnotationRevision(

            annotation=new_annotation, 

            author=author,

            title=title,

            description=description,

            fragment=fragment,

            state=AnnotationRevision.ACCEPTED

        )

        initial_revision.save()

        initial_revision.set_tags(tags_json)

        # Create stats object

        new_annotation_stats = AnnotationStats(annotation=new_annotation)

        new_annotation_stats.set_tags_stats()

        new_annotation_stats.save()

        # Link everything to parent

        new_annotation.current_revision = initial_revision

        new_annotation.stats = new_annotation_stats

        new_annotation.save()

        iconolab_signals.revision_created.send(sender=AnnotationRevision, instance=initial_revision)

        return new_annotation

    @transaction.atomic

    def get_annotations_contributed_for_user(self, user):

        """

            user is the user whom we want to get the contributed annotations

            Returns the list of all the annotations on which the user submitted a revision but did not create the annotation

            List of dict in the format:

            {

                "annotation_obj": annotation object,

                "revisions_count": revisions count for user

                "awaiting_count": awaiting revisions for user on this annotation

                "accepted_count": accepted revisions for user

                "latest_submitted_revision": date of the latest submitted revision from user on annotation

            }

        """

        latest_revision_on_annotations = []

        user_contributed_annotations = Annotation.objects.filter(revisions__author=user).exclude(author=user).prefetch_related(

            'current_revision',

            'revisions',

            'image',

            'image__item',

            'image__item__collection').distinct()

        for annotation in user_contributed_annotations.all():

            latest_revision_on_annotations.append(annotation.revisions.filter(author=user).latest(field_name="created"))

        contributed_list = []

        if latest_revision_on_annotations:

            latest_revision_on_annotations.sort(key=lambda item:item.created, reverse=True)

            contributed_list= [

                {

                    "annotation_obj": revision.annotation, 

                    "revisions_count": revision.annotation.revisions.filter(author=user).count(),

                    "awaiting_count": revision.annotation.revisions.filter(author=user, state=AnnotationRevision.AWAITING).count(),

                    "accepted_count": revision.annotation.revisions.filter(author=user, state=AnnotationRevision.ACCEPTED).count(),

                    "latest_submitted_revision": revision.created

                }

                for revision in latest_revision_on_annotations

            ]

        logger.debug(contributed_list)

        return contributed_list

    @transaction.atomic

    def get_annotations_commented_for_user(self, user, ignore_revisions_comments=True):

        """

            user is the user for which we want to get the commented annotations

            ignore_revisions_comment allows to filter comments that are associated with a revision

            Returns a list of all annotations on which a given user commented with user-comments-related data

            List of dict in the format:

            {

                "annotation_obj": annotation object,

                "comment_count": comment count for user

                "latest_comment_date": date of the latest comment from user on annotation

            }

        """

        user_comments = IconolabComment.objects.filter(user=user, content_type__app_label='iconolab', content_type__model='annotation').order_by('-submit_date')

        if ignore_revisions_comments:

            logger.debug(user_comments.count())

            user_comments = user_comments.filter(revision__isnull=True)

            logger.debug(user_comments.count())

        all_user_comments_data = [(comment.object_pk, comment.submit_date) for comment in user_comments]

        unique_ordered_comments_data = []

        for (id, submit_date) in all_user_comments_data: 

            if id not in [item["annotation_id"] for item in unique_ordered_comments_data]:

                unique_ordered_comments_data.append({"annotation_id": id, "latest_comment_date": submit_date})

        commented_annotations = Annotation.objects.filter(id__in=[item["annotation_id"] for item in unique_ordered_comments_data]).prefetch_related(

            'current_revision',

            'revisions',

            'image',

            'image__item',

            'image__item__collection'

        ).distinct()

        sorted_annotations_list = []

        logger.debug(unique_ordered_comments_data)

        for comment_data in unique_ordered_comments_data:

            annotation_obj = commented_annotations.get(id=comment_data["annotation_id"])

            sorted_annotations_list.append(

                {

                    "annotation_obj": annotation_obj, 

                    "comment_count_for_user": user_comments.filter(object_pk=annotation_obj.id).count(), 

                    "latest_comment_date": comment_data["latest_comment_date"]

                }

            )

        return sorted_annotations_list

class Annotation(models.Model):

    """

        Annotation objects are created on a given image, each annotation have a list of revisions to keep track of its history, the latest revision is the 'current revision' 

        that will be displayed by default in most pages. 

        Annotation data (title, description, fragment) is thus stored in the revision.

        Annotations can be considered validated or not depending on the metacategories posted in their comments through the attribute validation_state. Their validation state

        can also be overriden and in such case we can use validation_state_overriden attribute to remember it in the model (so for instance if an admin un-validates an annotation

        we could block it from being validated again)

    """

    UNVALIDATED = 0

    VALIDATED = 1

    VALIDATION_STATES = (

        (UNVALIDATED, 'unvalidated'),

        (VALIDATED, 'validated'),

    )

    annotation_guid = models.UUIDField(default=uuid.uuid4, editable=False)

    image = models.ForeignKey('Image', related_name='annotations', on_delete=models.CASCADE)

    source_revision = models.ForeignKey('AnnotationRevision', related_name='source_related_annotation', blank=True, null=True)

    current_revision = models.OneToOneField('AnnotationRevision', related_name='current_for_annotation', blank=True, null=True)

    author = models.ForeignKey(User, null=True)

    created = models.DateTimeField(auto_now_add=True, null=True)

    comments = GenericRelation('IconolabComment', content_type_field='content_type_id', object_id_field='object_pk')

    validation_state = models.IntegerField(choices=VALIDATION_STATES, default=UNVALIDATED)

    validation_state_overriden = models.BooleanField(default=False)

    objects = AnnotationManager()

    def __str__(self):

        return str(self.annotation_guid)+":"+self.current_revision.title

    @property

    def awaiting_revisions_count(self):

        return self.revisions.filter(state=AnnotationRevision.AWAITING).distinct().count()

    @property

    def accepted_revisions_count(self):

        return self.revisions.filter(state=AnnotationRevision.ACCEPTED).distinct().count()

    @property

    def rejected_revisions_count(self):

        return self.revisions.filter(state=AnnotationRevision.REJECTED).distinct().count()

    @property

    def studied_revisions_count(self):

        return self.revisions.filter(state=AnnotationRevision.STUDIED).distinct().count()

    @property

    def total_revisions_count(self):

        return self.revisions.distinct().count()

    @property

    def collection(self):