from django.contrib.contenttypes.fields import GenericRelation
from django.core.urlresolvers import reverse
from django.db import models
from django.utils.datastructures import SortedDict
from django.utils.translation import ugettext as _
from django.utils.translation import ugettext_lazy, ugettext_noop

from openslides.agenda.models import Item, Speaker
from openslides.core.models import Tag
from openslides.config.api import config
from openslides.poll.models import (BaseOption, BasePoll, BaseVote,
                                    CollectDefaultVotesMixin,
                                    PublishPollMixin)
from openslides.projector.models import SlideMixin
from openslides.utils.exceptions import OpenSlidesError
from openslides.utils.models import AbsoluteUrlMixin
from openslides.utils.rest_api import RESTModelMixin
from openslides.users.models import User


class AssignmentRelatedUser(RESTModelMixin, models.Model):
    """
    Many to Many table between an assignment and user.
    """
    STATUS_CANDIDATE = 1
    STATUS_ELECTED = 2
    STATUS_BLOCKED = 3
    STATUSES = (
        (STATUS_CANDIDATE, ugettext_lazy('candidate')),
        (STATUS_ELECTED, ugettext_lazy('elected')),
        (STATUS_BLOCKED, ugettext_lazy('blocked')),
    )

    assignment = models.ForeignKey(
        'Assignment',
        db_index=True,
        related_name='assignment_related_users')
    user = models.ForeignKey(User, db_index=True)
    status = models.IntegerField(
        choices=STATUSES,
        default=STATUS_CANDIDATE)

    class Meta:
        unique_together = ('assignment', 'user')

    def __str__(self):
        return "%s <-> %s" % (self.assignment, self.user)

    def get_root_rest_element(self):
        """
        Returns the assignment to this instance which is the root REST element.
        """
        return self.assignment


class Assignment(RESTModelMixin, SlideMixin, AbsoluteUrlMixin, models.Model):
    slide_callback_name = 'assignment'

    PHASE_SEARCH = 1
    PHASE_VOTING = 2
    PHASE_FINISHED = 3

    PHASES = (
        (PHASE_SEARCH, ugettext_lazy('Searching for candidates')),
        (PHASE_VOTING, ugettext_lazy('Voting')),
        (PHASE_FINISHED, ugettext_lazy('Finished')),
    )

    title = models.CharField(
        max_length=100,
        verbose_name=ugettext_lazy("Title"))
    """
    Title of the assignment.
    """

    description = models.TextField(
        blank=True,
        verbose_name=ugettext_lazy("Description"))
    """
    Text to describe the assignment.
    """

    open_posts = models.PositiveSmallIntegerField(
        verbose_name=ugettext_lazy("Number of members to be elected"))
    """
    The number of members to be elected.
    """

    poll_description_default = models.CharField(
        max_length=79,
        blank=True,
        verbose_name=ugettext_lazy("Default comment on the ballot paper"))
    """
    Default text for the poll description.
    """

    phase = models.IntegerField(
        choices=PHASES,
        default=PHASE_SEARCH)
    """
    Phase in which the assignment is.
    """

    related_users = models.ManyToManyField(
        User,
        through='AssignmentRelatedUser')
    """
    Users that a candidates, elected or blocked as candidate.

    See AssignmentRelatedUser for more infos.
    """

    tags = models.ManyToManyField(Tag, blank=True)
    """
    Tags for the assignment.
    """

    items = GenericRelation(Item)
    """
    Agenda items for this assignment.
    """

    class Meta:
        permissions = (
            ('can_see_assignments', ugettext_noop('Can see elections')),
            ('can_nominate_other', ugettext_noop('Can nominate another participant')),
            ('can_nominate_self', ugettext_noop('Can nominate oneself')),
            ('can_manage_assignments', ugettext_noop('Can manage elections')),
        )
        ordering = ('title', )
        verbose_name = ugettext_noop('Election')

    def __str__(self):
        return self.title

    def get_absolute_url(self, link='detail'):
        """
        Returns absolute url to the assignment instance.
        """
        if link == 'detail':
            url = reverse('assignment_detail', args=[str(self.pk)])
        elif link == 'update':
            url = reverse('assignment_update', args=[str(self.pk)])
        elif link == 'delete':
            url = reverse('assignment_delete', args=[str(self.pk)])
        else:
            url = super().get_absolute_url(link)
        return url

    def get_slide_context(self, **context):
        """
        Retuns the context to generate the assignment slide.
        """
        return super().get_slide_context(
            polls=self.polls.filter(published=True),
            vote_results=self.vote_results(only_published=True),
            **context)

    @property
    def candidates(self):
        """
        Queryset that represents the candidates for the assignment.
        """
        return self.related_users.filter(
            assignmentrelateduser__status=AssignmentRelatedUser.STATUS_CANDIDATE)

    @property
    def elected(self):
        """
        Queryset that represents all elected users for the assignment.
        """
        return self.related_users.filter(
            assignmentrelateduser__status=AssignmentRelatedUser.STATUS_ELECTED)

    @property
    def blocked(self):
        """
        Queryset that represents all blocked users for the assignment.
        """
        return self.related_users.filter(
            assignmentrelateduser__status=AssignmentRelatedUser.STATUS_BLOCKED)

    def is_candidate(self, user):
        """
        Returns True if user is a candidate.

        Costs one database query.
        """
        return self.candidates.filter(pk=user.pk).exists()

    def is_elected(self, user):
        """
        Returns True if the user is elected for this assignment.

        Costs one database query.
        """
        return self.elected.filter(pk=user.pk).exists()

    def is_blocked(self, user):
        """
        Returns True if the user is blockt for candidature.

        Costs one database query.
        """
        return self.blocked.filter(pk=user.pk).exists()

    def set_candidate(self, user):
        """
        Adds the user as candidate.
        """
        related_user, __ = self.assignment_related_users.update_or_create(
            user=user,
            defaults={'status': AssignmentRelatedUser.STATUS_CANDIDATE})

    def set_elected(self, user):
        """
        Makes user an elected user for this assignment.
        """
        related_user, __ = self.assignment_related_users.update_or_create(
            user=user,
            defaults={'status': AssignmentRelatedUser.STATUS_ELECTED})

    def set_blocked(self, user):
        """
        Block user from this assignment, so he can not get an candidate.
        """
        related_user, __ = self.assignment_related_users.update_or_create(
            user=user,
            defaults={'status': AssignmentRelatedUser.STATUS_BLOCKED})

    def delete_related_user(self, user):
        """
        Delete the connection from the assignment to the user.
        """
        self.assignment_related_users.filter(user=user).delete()

    def set_phase(self, phase):
        """
        Sets the phase attribute of the assignment.

        Raises a ValueError if the phase is not valide.
        """
        if phase not in dict(self.PHASES):
            raise ValueError("Invalid phase %s" % phase)

        self.phase = phase

    def create_poll(self):
        """
        Creates an new poll for the assignment and adds all candidates to all
        lists of speakers of related agenda items.
        """
        candidates = self.candidates.all()

        # Find out the method of the election
        if config['assignment_poll_vote_values'] == 'votes':
            yesnoabstain = False
        elif config['assignment_poll_vote_values'] == 'yesnoabstain':
            yesnoabstain = True
        else:
            # config['assignment_poll_vote_values'] == 'auto'
            # candidates <= available posts -> yes/no/abstain
            if len(candidates) <= (self.open_posts - self.elected.count()):
                yesnoabstain = True
            else:
                yesnoabstain = False

        # Create the poll with the candidates.
        poll = self.polls.create(
            description=self.poll_description_default,
            yesnoabstain=yesnoabstain)
        poll.set_options({'candidate': user} for user in candidates)

        # Add all candidates to all agenda items for this assignment
        # TODO: Try to do this in a bulk create
        for item in self.items.all():
            for candidate in self.candidates:
                try:
                    Speaker.objects.add(candidate, item)
                except OpenSlidesError:
                    # The Speaker is already on the list. Do nothing.
                    # TODO: Find a smart way not to catch the error concerning AnonymousUser.
                    pass

        return poll

    def vote_results(self, only_published):
        """
        Returns a table represented as a list with all candidates from all
        related polls and their vote results.
        """
        vote_results_dict = SortedDict()

        polls = self.polls.all()
        if only_published:
            polls = polls.filter(published=True)

        # All PollOption-Objects related to this assignment
        options = []
        for poll in polls:
            options += poll.get_options()

        for option in options:
            candidate = option.candidate
            if candidate in vote_results_dict:
                continue
            vote_results_dict[candidate] = []
            for poll in polls:
                votes = {}
                try:
                    # candidate related to this poll
                    poll_option = poll.get_options().get(candidate=candidate)
                    for vote in poll_option.get_votes():
                        votes[vote.value] = vote.print_weight()
                except AssignmentOption.DoesNotExist:
                    # candidate not in related to this poll
                    votes = None
                vote_results_dict[candidate].append(votes)
        return vote_results_dict

    def get_agenda_title(self):
        return str(self)

    def get_agenda_title_supplement(self):
        return '(%s)' % _('Assignment')


class AssignmentVote(RESTModelMixin, BaseVote):
    option = models.ForeignKey('AssignmentOption')

    def get_root_rest_element(self):
        """
        Returns the assignment to this instance which is the root REST element.
        """
        return self.option.poll.assignment


class AssignmentOption(RESTModelMixin, BaseOption):
    poll = models.ForeignKey('AssignmentPoll')
    candidate = models.ForeignKey(User)
    vote_class = AssignmentVote

    def __str__(self):
        return str(self.candidate)

    def get_root_rest_element(self):
        """
        Returns the assignment to this instance which is the root REST element.
        """
        return self.poll.assignment


class AssignmentPoll(RESTModelMixin, SlideMixin, CollectDefaultVotesMixin,
                     PublishPollMixin, AbsoluteUrlMixin, BasePoll):
    slide_callback_name = 'assignmentpoll'
    option_class = AssignmentOption

    assignment = models.ForeignKey(Assignment, related_name='polls')
    yesnoabstain = models.BooleanField(default=False)
    description = models.CharField(
        max_length=79,
        blank=True,
        verbose_name=ugettext_lazy("Comment on the ballot paper"))

    def __str__(self):
        return _("Ballot %d") % self.get_ballot()

    def get_absolute_url(self, link='update'):
        """
        Return an URL for the poll.

        The keyargument 'link' can be 'update' or 'delete'.
        """
        if link == 'update':
            url = reverse('assignmentpoll_update', args=[str(self.pk)])
        elif link == 'delete':
            url = reverse('assignmentpoll_delete', args=[str(self.pk)])
        else:
            url = super().get_absolute_url(link)
        return url

    def get_assignment(self):
        return self.assignment

    def get_vote_values(self):
        if self.yesnoabstain:
            return [ugettext_noop('Yes'), ugettext_noop('No'), ugettext_noop('Abstain')]
        else:
            return [ugettext_noop('Votes')]

    def get_ballot(self):
        return self.assignment.polls.filter(id__lte=self.pk).count()

    def get_percent_base_choice(self):
        return config['assignment_poll_100_percent_base']

    def append_pollform_fields(self, fields):
        fields.append('description')
        super().append_pollform_fields(fields)

    def get_slide_context(self, **context):
        return super().get_slide_context(poll=self)

    def get_root_rest_element(self):
        """
        Returns the assignment to this instance which is the root REST element.
        """
        return self.assignment