from datetime import datetime

  from django.contrib.auth.models import AbstractUser, UserManager

  from django.core.exceptions import PermissionDenied, SuspiciousOperation
  from django.db import IntegrityError

  from django.db.models import *

  from django.utils.timezone import now

  from simple_email_confirmation import SimpleEmailConfirmationUserMixin

  from fields import MaskField

  # Hack to fix AbstractUser before subclassing it
  AbstractUser._meta.get_field('email')._unique = True

  AbstractUser._meta.get_field('username')._unique = False

  class EmailOnlyUserManager(UserManager):
      """
      A tiny extension of Django's UserManager which correctly creates users
      without usernames (using emails instead).
      """
  
      def _create_user(self, email, password, is_staff, is_superuser, **extra_fields):
          """

          Creates and saves a User with the given email and password.

          """
          email = self.normalize_email(email)
          user = self.model(email=email,
                            is_staff=is_staff, is_active=True,
                            is_superuser=is_superuser,
                            date_joined=now(), **extra_fields)
          user.set_password(password)
          user.save(using=self._db)
          return user
  
      def create_user(self, email, password=None, **extra_fields):
          return self._create_user(email, password, False, False, **extra_fields)

      def create_superuser(self, email, password, **extra_fields):

          return self._create_user(email, password, True, True, **extra_fields)

  
  
  class User(AbstractUser, SimpleEmailConfirmationUserMixin):

      """
      An extension of Django's default user model.
      We use email as the username field, and include enrolled sections here
      """
      objects = EmailOnlyUserManager()

      USERNAME_FIELD = 'email'
      REQUIRED_FIELDS = []

      sections = ManyToManyField('Section', help_text="The sections which the user is enrolled in")

      def is_in_section(self, section):

          return self.sections.filter(pk=section.pk).exists()

  
      def pull(self, flashcard):
          if not self.is_in_section(flashcard.section):
              raise ValueError("User not in the section this flashcard belongs to")
          user_card = UserFlashcard.objects.create(user=self, flashcard=flashcard)
          user_card.pulled = datetime.now()
          user_card.save()

      def get_deck(self, section):
          if not self.is_in_section(section):
              raise ObjectDoesNotExist("User not enrolled in section")
          return Flashcard.objects.all().filter(userflashcard__user=self).filter(section=section)

  class UserFlashcard(Model):

      """
      Represents the relationship between a user and a flashcard by:

      1. A user has a flashcard in their deck
      2. A user used to have a flashcard in their deck
      3. A user has a flashcard hidden from them

      """

      user = ForeignKey('User')

      mask = MaskField(max_length=255, null=True, blank=True, default=None,
                       help_text="The user-specific mask on the card")

      pulled = DateTimeField(blank=True, null=True, default=None, help_text="When the user pulled the card")

      flashcard = ForeignKey('Flashcard')

  
      class Meta:

          # There can be at most one UserFlashcard for each User and Flashcard

          unique_together = (('user', 'flashcard'),)
          index_together = ["user", "flashcard"]

          # By default, order by most recently pulled

          ordering = ['-pulled']

  class FlashcardHide(Model):
      """
      Represents the property of a flashcard being hidden by a user.
      Each instance of this class represents a single user hiding a single flashcard.
      If reason is null, the flashcard was just hidden.
      If reason is not null, the flashcard was reported, and reason is the reason why it was reported.
      """
      user = ForeignKey('User')
      flashcard = ForeignKey('Flashcard')
      reason = CharField(max_length=255, blank=True, null=True)
      hidden = DateTimeField(auto_now_add=True)
  
      class Meta:
          # There can only be one FlashcardHide object for each User and Flashcard
          unique_together = (('user', 'flashcard'),)
          index_together = ["user", "flashcard"]

  class Flashcard(Model):
      text = CharField(max_length=255, help_text='The text on the card')

      section = ForeignKey('Section', help_text='The section with which the card is associated')

      pushed = DateTimeField(auto_now_add=True, help_text="When the card was first pushed")

      material_date = DateTimeField(default=now, help_text="The date with which the card is associated")

      previous = ForeignKey('Flashcard', null=True, blank=True, default=None,

                            help_text="The previous version of this card, if one exists")
      author = ForeignKey(User)
      is_hidden = BooleanField(default=False)

      hide_reason = CharField(blank=True, null=True, max_length=255,
                              default=None, help_text="Reason for hiding this card")

      mask = MaskField(max_length=255, null=True, blank=True, help_text="The mask on the card")

      class Meta:
          # By default, order by most recently pushed
          ordering = ['-pushed']
  
      def is_hidden_from(self, user):
          """
          A card can be hidden globally, but if a user has the card in their deck,
          this visibility overrides a global hide.
          :param user:
          :return: Whether the card is hidden from the user.
          """
          result = user.userflashcard_set.filter(flashcard=self)
          if not result.exists(): return self.is_hidden
          return result[0].is_hidden()

      def add_to_deck(self, user):
          if not user.is_in_section(self.section):
              raise PermissionDenied("You don't have the permission to add this card")
          try:
              user_flashcard = UserFlashcard.objects.create(user=user, flashcard=self, mask=self.mask)
          except IntegrityError:
              raise SuspiciousOperation("The flashcard is already in the user's deck")
          user_flashcard.save()
          return user_flashcard

      def edit(self, user, new_flashcard):
          """
          Creates a new flashcard if a new flashcard should be created when the given user edits this flashcard.
          Sets up everything correctly so this object, when saved, will result in the appropriate changes.
          :param user: The user editing this card.
          :param new_flashcard: The new information, namely a dict containg 'material_date', 'text', and 'mask' keys.
          """
          if not user.is_in_section(self.section):
              raise PermissionDenied("You don't have the permission to edit this card")
  
          # content_changed is True iff either material_date or text were changed
          content_changed = False
          # create_new is True iff the user editing this card is the author of this card
          # and there are no other users with this card in their decks
          create_new = user != self.author or \

                       UserFlashcard.objects.filter(flashcard=self).exclude(user=user).exists()

  
          if 'material_date' in new_flashcard and self.material_date != new_flashcard['material_date']:
              content_changed |= True
              self.material_date = new_flashcard['material_date']
          if 'text' in new_flashcard and self.text != new_flashcard['text']:
              content_changed |= True
              self.text = new_flashcard['text']
          if create_new and content_changed:

              mask = self.mask
              pk = self.pk

              self.pk = None
              if 'mask' in new_flashcard:

                  mask = new_flashcard['mask']
              self.mask = mask
              self.previous_id = pk

              self.save()

          return create_new and content_changed

      @classmethod
      def cards_visible_to(cls, user):

          """
          :param user:
          :return: A queryset with all cards that should be visible to a user.
          """

          return cls.objects.filter(is_hidden=False).exclude(flashcardhide__user=user)

  class UserFlashcardQuiz(Model):

      """

      An event of a user being quizzed on a flashcard.

      """
      user_flashcard = ForeignKey(UserFlashcard)

      when = DateTimeField(auto_now=True)

      blanked_word = CharField(max_length=8, blank=True, help_text="The character range which was blanked")
      response = CharField(max_length=255, blank=True, null=True, help_text="The user's response")
      correct = NullBooleanField(help_text="The user's self-evaluation of their response")
  
      def status(self):
          """

          There are three stages of a quiz object:

            1. the user has been shown the card
            2. the user has answered the card

            3. the user has self-evaluated their response's correctness

          :return: string (evaluated, answered, viewed)
          """

          if self.correct is not None: return "evaluated"

          if self.response: return "answered"
          return "viewed"

  class Section(Model):

      """
      A UCSD course taught by an instructor during a quarter.

      We use the term "section" to avoid collision with the builtin keyword "class"

      We index gratuitously to support autofill and because this is primarily read-only

      """

      department = CharField(db_index=True, max_length=50)
      department_abbreviation = CharField(db_index=True, max_length=10)
      course_num = CharField(db_index=True, max_length=6)
      course_title = CharField(db_index=True, max_length=50)
      instructor = CharField(db_index=True, max_length=100)
      quarter = CharField(db_index=True, max_length=4)

      @classmethod
      def search(cls, terms):
          """
          Search all fields of all sections for a particular set of terms
          A matching section must match at least one field on each term
          :param terms:iterable
          :return: Matching QuerySet ordered by department and course number
          """
          final_q = Q()
          for term in terms:
              q = Q(department__icontains=term)
              q |= Q(department_abbreviation__icontains=term)
              q |= Q(course_title__icontains=term)
              q |= Q(course_num__icontains=term)
              q |= Q(instructor__icontains=term)
              final_q &= q
          qs = cls.objects.filter(final_q)
          # Have the database cast the course number to an integer so it will sort properly
          # ECE 35 should rank before ECE 135 even though '135' < '35' lexicographically

          qs = qs.extra(select={'course_num_int': "CAST(rtrim(course_num, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ') AS INTEGER)"})

          qs = qs.order_by('department_abbreviation', 'course_num_int')
          return qs

      @property

      def is_whitelisted(self):
          """
          :return: whether a whitelist exists for this section
          """
          return self.whitelist.exists()
  
      def is_user_on_whitelist(self, user):
          """
          :return: whether the user is on the waitlist for this section
          """

          return self.whitelist.filter(email=user.email).exists()

      class Meta:

          ordering = ['-course_title']

      @property

      def lecture_times(self):

          lecture_periods = self.lectureperiod_set.all()

          if not lecture_periods.exists(): return ''

          return ''.join(map(lambda x: x.weekday_letter, lecture_periods)) + ' ' + lecture_periods[0].short_start_time

  
      @property

      def long_name(self):

          return '%s %s (%s)' % (self.course_title, self.lecture_times, self.instructor)

  
      @property
      def short_name(self):
          return '%s %s' % (self.department_abbreviation, self.course_num)

      def get_feed_for_user(self, user):
          qs = Flashcard.objects.filter(section=self).exclude(userflashcard__user=user).order_by('pushed')
          return qs

      def __unicode__(self):
          return '%s %s: %s (%s %s)' % (

              self.department_abbreviation, self.course_num, self.course_title, self.instructor, self.quarter)

  class LecturePeriod(Model):
      """
      A lecture period for a section
      """
      section = ForeignKey(Section)

      week_day = IntegerField(help_text="1-indexed day of week, starting at Sunday")

      start_time = TimeField()
      end_time = TimeField()

      @property
      def weekday_letter(self):
          return ['?', 'S', 'M', 'T', 'W', 'Th', 'F', 'S', 'S'][self.week_day]
  
      @property
      def short_start_time(self):

          # lstrip 0 because windows doesn't support %-I
          return self.start_time.strftime('%I %p').lstrip('0')

      class Meta:
          unique_together = (('section', 'start_time', 'week_day'),)

          ordering = ['section', 'week_day']

  
  
  class WhitelistedAddress(Model):

      """
      An email address that has been whitelisted for a section at an instructor's request
      """

      email = EmailField()

      section = ForeignKey(Section, related_name='whitelist')