import logging

from django.conf import settings

from django.contrib import messages

from django.contrib.auth.decorators import login_required

from django.contrib.auth.models import User

from django.contrib.contenttypes.models import ContentType

from django.contrib.sites.models import Site

from django.core.exceptions import ObjectDoesNotExist

from django.core.paginator import EmptyPage, PageNotAnInteger, Paginator

from django.urls import reverse

from django.db.models import Count, Prefetch

from django.http import Http404

from django.shortcuts import HttpResponse, get_object_or_404, redirect, render

from django.views.generic import DetailView, RedirectView, TemplateView, View

from django.views.generic.base import ContextMixin

from notifications.models import Notification

from iconolab.forms.annotations import AnnotationRevisionForm

from iconolab.forms.bookmarks import BookmarkForm

from iconolab.models import (Annotation, AnnotationRevision, Bookmark,

                             BookmarkCategory, Collection, Folder,

                             IconolabComment, Image, Item, MetaCategory,

                             MetaCategoryInfo, Tag, TaggingInfo)

from iconolab.serializers import AnnotationRevisionSerializer

logger = logging.getLogger(__name__)

class GlobalHomepageView(View):

    """

        View for the opening page of Iconolab.

    """

    def get(self, request, *args, **kwargs):

        """

            Template is iconolab/home.html

            Context variables provided to the template are:

                collections_primary: list of collections to display as big images

                collections_secondary: list of collections to display as small links at the bottom

                homepage = True: used to pass checks in the partials/header.html

                    template to adjust the navbar to the homepage

        """

        context = {}

        context['collections_primary'] = Collection.objects.filter(show_image_on_home=True).all()

        context['collections_secondary'] = Collection.objects.filter(show_image_on_home=False).all()

        context['latest_annotations'] = Annotation.objects.order_by("-created").all()[:5]

        # Best contributors

        count_contributions = Annotation.objects.all()\

            .values('author').annotate(contributions=Count('author')).order_by('-contributions')[:10]

        best_authors = { u.id: u for u in User.objects.filter(id__in=[cc['author'] for cc in count_contributions])}

        context['best_contributors'] = [

            {'author': best_authors[cc['author']], 'contributions': cc['contributions']}

            for cc in count_contributions

        ]

        # Most accurate tags (tags with accuracy >= 4)

        # SELECT ti.tag_id, ar.title, COUNT(DISTINCT(a.id)) AS cnt

        # FROM iconolab_tagginginfo ti

        # JOIN iconolab_annotationrevision ar ON ti.revision_id = ar.id

        # JOIN iconolab_annotation a ON ar.annotation_id = a.id

        # WHERE ti.accuracy >= 4

        # GROUP BY ti.tag_id

        # ORDER BY cnt desc

        rows = TaggingInfo.objects\

            .filter(accuracy__gte=4)\

            .values('tag')\

            .annotate(annotation_count=Count('revision__annotation', distinct=True))\

            .order_by('-annotation_count')\

            .all()[:10]

        best_tags = {t.id: t for t in Tag.objects.filter(id__in=[r['tag'] for r in rows])}

        context['most_accurate_tags'] = [

            {'tag': best_tags[r['tag']], 'annotation_count': r['annotation_count']}

            for r in rows

        ]

        context['contact'] = settings.CONTACT_EMAIL

        context['homepage'] = True

        return render(request, 'iconolab/home.html', context)

class TestView(View):

    template_name = 'iconolab/compare.html'

    def get(self, request, *args, **kwargs):

        return render(request, self.template_name)

# Class with check_kwargs method to fetch objects from database depending on what level in the app we're currently at

class IconolabObjectView(object):

    """

        Superclass that defines method used in all object display views.

    """

    def check_kwargs(self, kwargs):

        '''

            Returns a boolean depending on wether (True) or not (False) the objects

            were found and a tuple containing the objects, with a select_related/prefetch_related

            on relevant related objects following this ordering:

            (collection, item, image, annotation, revision)

        '''

        objects_tuple = ()

        if 'collection_name' in kwargs.keys():

            try:

                objects_tuple += (Collection.objects.prefetch_related(

                    'items',

                    'items__images',

                    Prefetch(

                        'folders',

                        Folder.objects.annotate(items_nb=Count('item')).order_by('name')

                    )

                ).get(name=kwargs.get('collection_name')),)

            except (ValueError, Collection.DoesNotExist):

                return False, RedirectView.as_view(url=reverse('404error'))

        if 'item_guid' in kwargs.keys():

            try:

                objects_tuple += (Item.objects.prefetch_related('images', 'metadatas', 'images__stats').get(item_guid=kwargs.get('item_guid')),)

            except (ValueError, Item.DoesNotExist):

                return False, RedirectView.as_view(url=reverse('404error'))

        if 'image_guid' in kwargs.keys():

            try:

                objects_tuple += (Image.objects.prefetch_related('annotations', 'item', 'stats').get(image_guid=kwargs.get('image_guid')),)

            except (ValueError, Image.DoesNotExist):

                return False, RedirectView.as_view(url=reverse('404error'))

        if 'annotation_guid' in kwargs.keys():

            try:

                objects_tuple += (Annotation.objects.prefetch_related('current_revision', 'stats', 'image').get(annotation_guid=kwargs.get('annotation_guid')),)

            except (ValueError, Annotation.DoesNotExist):

                return False, RedirectView.as_view(url=reverse('404error'))

        if 'revision_guid' in kwargs.keys():

            try:

                objects_tuple += (AnnotationRevision.objects.prefetch_related('parent_revision').get(revision_guid=kwargs.get('revision_guid')),)

            except (ValueError, AnnotationRevision.DoesNotExist):

                return False, RedirectView.as_view(url=reverse('404error'))

        return True, objects_tuple

    def get_pagination_data(self, list_to_paginate, page, perpage, adjacent_pages_count, perpage_range=[5, 10, 25, 100], trailing_qarg=""):

        """

            Takes a queryset or a list and returns a dict with pagination data for display purposes

            Dict will be of the format:

            {

                page: the page to load (integer)

                perpage_range: a list of the page links to display (list of integers)

                perpage: the item count per page (integer)

                perpage_range: a list of the perpage values to display next to the page list (list of integers)

                trailing_qarg: optional trailing qarg for the paginations links (used in collection home to remember the state of each list between page loads) (string)

                list: the item list to display (list of objects)

                show_first: used in template to display links, will be True if 1 is not in page_range

                show_last: used in template to display links, will be True if page_count is not in page_range

                ellipsis_first: used in template to display links, will be True if page_range starts at 3 or more

                ellipsis_last: used in template to display links, will be True if page_range ends at last_page - 2 or less

            }

        """

        pagination_data = {}

        pagination_data["page"] = page

        pagination_data["perpage"] = perpage

        pagination_data["perpage_range"] = perpage_range

        pagination_data["trailing_qarg"] = trailing_qarg

        paginator = Paginator(list_to_paginate, perpage)

        try:

            pagination_data["list"] = paginator.page(page)

        except PageNotAnInteger:

            pagination_data["list"] = paginator.page(1)

        except EmptyPage:

            pagination_data["list"] = paginator.page(paginator.num_pages)

        pagination_data["page_range"] = [

            n for n in \

            range(page - adjacent_pages_count, page + adjacent_pages_count + 1) \

                if n > 0 and n <= paginator.num_pages

        ]

        pagination_data["show_first"] = page - adjacent_pages_count > 1

        pagination_data["ellipsis_first"] = pagination_data["show_first"] and (page - adjacent_pages_count != 2)

        pagination_data["show_last"] = page + adjacent_pages_count < paginator.num_pages

        pagination_data["ellipsis_last"] = pagination_data["show_last"] and (page + adjacent_pages_count != paginator.num_pages - 1)

        return pagination_data

class CollectionHomepageView(View, ContextMixin, IconolabObjectView):

    """

        View that displays a collection and four panels to show relevant paginated lists for collection:

        * item lists

        * annotations ordered by creation date

        * annotations ordered by revisions count

        * annotations where a metacategory that notifies contributors was called

    """

    def get(self, request, *args, **kwargs):

        """

            Template is iconolab/collection_home.html

            Url args are:

                - collection_name: 'name' attribute of the requested collection

            Queryargs understood by the view are:

                - show : panel that will be shown on page load, one of ['items', 'recent', 'revised', 'contributions'], default to "items"

                - items_page : item list page to load

                - items_perpage : item count per page

                - recent_page : recent annotations list page to load

                - recent_perpage : recent annotations count per page

                - revised_page : most revised annotations list page to load

                - revised_perpage : most revised annotations count per page

                - contributions_page : annotations with the most contribution calls list page to load

                - contributions_perpage : annotations with the most contribution calls count per page for item list

            Context variables provided to the template are:

                - collection: the collection object for the requested collection

                - collection_name : the collection_name url arg

                - items_pagination_data: pagination data dict in the format of the IconolabObjectView.get_pagination_data() method for the items list

                - recent_pagination_data: pagination data dict in the format of the IconolabObjectView.get_pagination_data() method for the recent annotations list

                - revised_pagination_data: pagination data dict in the format of the IconolabObjectView.get_pagination_data() method for the revised annotations list

                - contributions_pagination_data: pagination data dict in the format of the IconolabObjectView.get_pagination_data() method for the contribution calls annotations list

        """

        success, result = self.check_kwargs(kwargs)

        if success:

            (collection,) = result

        else:

            return result(request)

        context = super(CollectionHomepageView, self).get_context_data(**kwargs)

        context['collection_name'] = self.kwargs.get('collection_name', '')

        context['collection'] = collection

        # get Pagination and navigation query args

        try:

            items_page = int(request.GET.get('items_page', '1'))

        except ValueError:

            items_page = 1

        try:

            items_per_page = int(request.GET.get('items_perpage', '12'))

        except ValueError:

            items_per_page = 12

        try:

            recent_page = int(request.GET.get('recent_page', '1'))

        except ValueError:

            recent_page = 1

        try:

            recent_per_page = int(request.GET.get('recent_perpage', '10'))

        except ValueError:

            recent_per_page = 10

        try:

            revised_page = int(request.GET.get('revised_page', '1'))

        except ValueError:

            revised_page = 1

        try:

            revised_per_page = int(request.GET.get('revised_perpage', '10'))

        except ValueError:

            revised_per_page = 10

        try:

            contributions_page = int(request.GET.get('contributions_page', '1'))

        except ValueError:

            contributions_page = 1

        try:

            contributions_per_page = int(request.GET.get('contributions_perpage', '10'))

        except ValueError:

            contributions_per_page = 10

        active_list = request.GET.get('show', 'items')

        if active_list not in ['items', 'recent', 'revised', 'contributions']:

            active_list = 'items'

        context["active_list"] = active_list

        # Pagination values

        adjacent_pages_count = 2

        # Paginated objects list

        items_list = collection.items.order_by("metadatas__natural_key").prefetch_related('images', 'images__stats')

        folder = request.GET.get('folder', None)

        if folder is not None:

            items_list = items_list.filter(folders__folder_guid=folder)

            context['folder_name'] = Folder.objects.get(folder_guid=folder).name

        context['folder_guid'] = folder

        items_pagination_args = '&'.join([

            "recent_page="+str(recent_page),

            "recent_perpage="+str(recent_per_page),

            "revised_page="+str(revised_page),

            "revised_perpage="+str(revised_per_page),

            "contributions_page="+str(contributions_page),

            "contributions_perpage="+str(contributions_per_page)

        ])

        if folder is not None:

            items_pagination_args += "&folder=" + folder

        context["items_pagination_data"] = self.get_pagination_data(

            items_list.all(),

            items_page,

            items_per_page,

            adjacent_pages_count,

            perpage_range=[6, 12, 48, 192],

            trailing_qarg=items_pagination_args

        )

        # Paginated recent annotations list

        recent_annotations = Annotation.objects.filter(image__item__collection__name=collection.name).select_related('image', 'author').prefetch_related(

            'current_revision',

            'stats',

            'stats__contributors'

        ).order_by('-current_revision__created')

        context["recent_pagination_data"] = self.get_pagination_data(

            recent_annotations,

            recent_page,

            recent_per_page,

            adjacent_pages_count,

            trailing_qarg="&items_page="+str(items_page)

            +"&items_perpage="+str(items_per_page)

            +"&revised_page="+str(revised_page)

            +"&revised_perpage="+str(revised_per_page)

            +"&contributions_page="+str(contributions_page)

            +"&contributions_perpage="+str(contributions_per_page)

        )

        # Paginated revised annotations list

        revised_annotations = Annotation.objects.filter(image__item__collection__name=collection.name).select_related('image', 'author').prefetch_related(

            'current_revision',

            'stats',

            'stats__contributors'

        ).annotate(revision_count=Count('revisions')).order_by('-revision_count')

        context["revised_pagination_data"] = self.get_pagination_data(

            revised_annotations,

            revised_page,

            revised_per_page,

            adjacent_pages_count,

            trailing_qarg="&items_page="+str(items_page)

            +"&items_perpage="+str(items_per_page)

            +"&recent_page="+str(recent_page)

            +"&recent_perpage="+str(recent_per_page)

            +"&contributions_page="+str(contributions_page)

            +"&contributions_perpage="+str(contributions_per_page)

        )

        # Paginated contribution calls annotation list

        contrib_calls_annotations_ids = list(set(MetaCategoryInfo.objects.filter(

            metacategory__collection__name=collection.name,

            metacategory__triggers_notifications=MetaCategory.CONTRIBUTORS

        ).order_by('comment__submit_date').values_list('comment__object_pk', flat=True)))

        collection_annotations = \

            Annotation.objects.filter(id__in=contrib_calls_annotations_ids)\

                .select_related('image', 'current_revision')\

                .prefetch_related(

                    'stats',

                    'stats__contributors',

                    Prefetch(

                        'current_revision__tagginginfo_set',

                        queryset=TaggingInfo.objects.select_related('tag')

                    )

                )\

                .all()

        collection_ann_dict = dict([(str(annotation.id), annotation) for annotation in collection_annotations])

        contributions_annotations = [collection_ann_dict[id] for id in contrib_calls_annotations_ids]

        context["contributions_pagination_data"] = self.get_pagination_data(

            contributions_annotations,

            contributions_page,

            contributions_per_page,

            adjacent_pages_count,

            trailing_qarg="&items_page="+str(items_page)

            +"&items_perpage="+str(items_per_page)

            +"&recent_page="+str(recent_page)

            +"&recent_perpage="+str(recent_per_page)

            +"&revised_page="+str(revised_page)

            +"&revised_perpage="+str(revised_per_page)

        )

        context['bookmark_form'] = BookmarkForm(user=request.user)

        return render(request, 'iconolab/collection_home.html', context)