from json import loads
  from collections import Iterable

  from django.utils.datetime_safe import datetime

  from django.utils.timezone import now

  from flashcards.models import Section, LecturePeriod, User, Flashcard, UserFlashcardQuiz, UserFlashcard

  from flashcards.validators import FlashcardMask, OverlapIntervalException

  from rest_framework import serializers

  from rest_framework.fields import EmailField, BooleanField, CharField, IntegerField, DateTimeField, empty, \

      SerializerMethodField, FloatField

  from rest_framework.serializers import ModelSerializer, Serializer, PrimaryKeyRelatedField, ListField

  from rest_framework.validators import UniqueValidator

  from flashy.settings import QUARTER_END, QUARTER_START

  
  
  class EmailSerializer(Serializer):
      email = EmailField(required=True)

  class LoginSerializer(EmailSerializer):

      password = CharField(required=True)

  class RegistrationSerializer(Serializer):

      email = EmailField(required=True, validators=[UniqueValidator(queryset=User.objects.all())])

      password = CharField(required=True, min_length=8)

  
  
  class PasswordResetRequestSerializer(EmailSerializer):
      def validate_email(self, value):
          try:
              User.objects.get(email=value)
              return value
          except User.DoesNotExist:
              raise serializers.ValidationError('No user exists with that email')
  
  
  class PasswordResetSerializer(Serializer):

      new_password = CharField(required=True, allow_blank=False, min_length=8)

      uid = IntegerField(required=True)
      token = CharField(required=True)
  
      def validate_uid(self, value):
          try:
              User.objects.get(id=value)
              return value
          except User.DoesNotExist:
              raise serializers.ValidationError('Could not verify reset token')

  class EmailVerificationSerializer(Serializer):
      confirmation_key = CharField()

  class UserUpdateSerializer(Serializer):
      old_password = CharField(required=False)

      new_password = CharField(required=False, allow_blank=False, min_length=8)

  
      def validate(self, data):
          if 'new_password' in data and 'old_password' not in data:
              raise serializers.ValidationError('old_password is required to set a new_password')
          return data

  class LecturePeriodSerializer(ModelSerializer):

      class Meta:

          model = LecturePeriod
          exclude = 'id', 'section'

  class SectionSerializer(ModelSerializer):

      lecture_times = CharField()

      short_name = CharField()
      long_name = CharField()

      can_enroll = SerializerMethodField()

      is_enrolled = SerializerMethodField()

      class Meta:

          model = Section

      def get_can_enroll(self, obj):
          if 'user' not in self.context: return False
          if not obj.is_whitelisted: return True
          return obj.is_user_on_whitelist(self.context['user'])

      def get_is_enrolled(self, obj):
          if 'user' not in self.context: return False
          return obj.is_user_enrolled(self.context['user'])

  class DeepSectionSerializer(SectionSerializer):
      lectures = LecturePeriodSerializer(source='lectureperiod_set', many=True, read_only=True)

  class FeedRequestSerializer(Serializer):
      page = IntegerField(min_value=1, default=1, required=False)
  
      def validate(self, attrs):
          if not isinstance(attrs['page'], int):
              raise serializers.ValidationError("Invalid page number")
          return attrs

  class UserSerializer(ModelSerializer):

      email = EmailField(required=False)

      sections = SectionSerializer(many=True)

      class Meta:

          model = User

          fields = ("sections", "email", "is_confirmed", "last_login", "date_joined", 'locked')

  class MaskFieldSerializer(serializers.Field):
      default_error_messages = {
          'max_length': 'Ensure this field has no more than {max_length} characters.',
          'interval': 'Ensure this field has valid intervals.',
          'overlap': 'Ensure this field does not have overlapping intervals.'
      }
  
      def to_representation(self, value):

          return map(list, self._make_mask(value))

      def to_internal_value(self, value):

          if not isinstance(value, list):
              value = loads(value)
          return self._make_mask(value)

  
      def _make_mask(self, data):

          try:

              mask = FlashcardMask(data)

          except ValueError:
              raise serializers.ValidationError("Invalid JSON for MaskField")

          except TypeError:
              raise serializers.ValidationError("Invalid data for MaskField.")
          except OverlapIntervalException:
              raise serializers.ValidationError("Invalid intervals for MaskField data.")
          if len(mask) > 32:
              raise serializers.ValidationError("Too many intervals in the mask.")
          return mask

  class FlashcardSerializer(ModelSerializer):

      is_hidden = SerializerMethodField()

      is_in_deck = SerializerMethodField()

      is_authored_by_user = SerializerMethodField()

      material_week_num = IntegerField(read_only=True)

      material_date = DateTimeField(default=now)

      mask = MaskFieldSerializer(allow_null=True)

      display_mask = SerializerMethodField()

      score = FloatField(read_only=True)

      def validate_material_date(self, value):
          # TODO: make this dynamic

          if QUARTER_START <= value <= QUARTER_END:

              return value

          else:
              raise serializers.ValidationError("Material date is outside allowed range for this quarter")

      def validate_pushed(self, value):
          if value > datetime.now():
              raise serializers.ValidationError("Invalid creation date for the Flashcard")
          return value

      def validate_mask(self, value):

          if value is None:
              return None

          if len(self.initial_data['text']) < value.max_offset():

              raise serializers.ValidationError("Mask out of bounds")
          return value

      def get_is_hidden(self, obj):
          if 'user' not in self.context: return False
          return obj.is_hidden_from(self.context['user'])

      def get_is_in_deck(self, obj):
          if 'user' not in self.context: return False
          return obj.is_in_deck(self.context['user'])

      def get_is_authored_by_user(self, obj):
          if 'user' not in self.context: return False
          return obj.author == self.context['user']

      def get_display_mask(self, obj):
          if 'user' in self.context:
              userflashcard = UserFlashcard.objects.filter(flashcard=obj, user=self.context['user'])
              if userflashcard.exists() and userflashcard.get().mask:
                  return MaskFieldSerializer().to_representation(userflashcard.get().mask)
          return MaskFieldSerializer().to_representation(obj.mask)

      class Meta:
          model = Flashcard

          exclude = 'author', 'previous', 'hide_reason'

  
  
  class FlashcardUpdateSerializer(serializers.Serializer):

      text = CharField(max_length=255, required=False)
      material_date = DateTimeField(required=False)
      mask = MaskFieldSerializer(required=False)

  
      def validate_material_date(self, date):

          if date > QUARTER_END:

              raise serializers.ValidationError("Invalid material_date for the flashcard")
          return date

  
      def validate(self, attrs):
          # Make sure that at least one of the attributes was passed in
          if not any(i in attrs for i in ['material_date', 'text', 'mask']):
              raise serializers.ValidationError("No new value passed in")

          return attrs
  
  
  class QuizRequestSerializer(serializers.Serializer):

      sections = ListField(child=IntegerField(min_value=1), required=False, default=[])

      material_date_begin = DateTimeField(default=QUARTER_START)
      material_date_end = DateTimeField(default=QUARTER_END)

      def update(self, instance, validated_data):
          pass

  
      def create(self, validated_data):

          return validated_data

  
      def validate_material_date_begin(self, value):
          if QUARTER_START <= value <= QUARTER_END:
              return value
          raise serializers.ValidationError("Invalid begin date for the flashcard range")
  
      def validate_material_date_end(self, value):
          if QUARTER_START <= value <= QUARTER_END:
              return value
          raise serializers.ValidationError("Invalid end date for the flashcard range")
  
      def validate_sections(self, value):

          if value is not None and not isinstance(value, Iterable):
              raise serializers.ValidationError("Invalid section format. Expecting a list or no value.")
          if value is None or len(value) == 0:

              return Section.objects.all()

          section_filter = Section.objects.filter(pk__in=value)
          if not section_filter.exists():

              raise serializers.ValidationError("Those aren't valid sections")
          return value

  
      def validate(self, attrs):
          if attrs['material_date_begin'] > attrs['material_date_end']:
              raise serializers.ValidationError("Invalid range")
          if 'sections' not in attrs:
              attrs['sections'] = self.validate_sections(None)

          return attrs
  
  
  class QuizResponseSerializer(ModelSerializer):
      pk = PrimaryKeyRelatedField(queryset=UserFlashcardQuiz.objects.all(), many=True)
      section = PrimaryKeyRelatedField(queryset=Section.objects.all())
      text = CharField(max_length=255)
      mask = ListField(child=IntegerField())

      def __init__(self, instance=None, mask=[], data=empty, **kwargs):

          super(QuizResponseSerializer, self).__init__(instance=instance, data=data, **kwargs)
          self.mask = self._validate_mask(mask)
  
      def to_representation(self, instance):
          return {

              'pk': instance.pk,

              'section': instance.user_flashcard.flashcard.section.pk,
              'text': instance.user_flashcard.flashcard.text,
              'mask': self.mask
          }
  
      def _validate_mask(self, value):

          if not isinstance(value, list) and value is not None:
              raise serializers.ValidationError("The selected mask has to be a list " + str(value))

          if value is None or len(value) == 0:
              return []

          if len(value) == 2 and (0 <= value[0] and value[1] <= len(self.instance.user_flashcard.flashcard.text)):

              return value
          raise serializers.ValidationError("Invalid mask for the flashcard")
  
      class Meta:
          model = UserFlashcardQuiz
  
  
  class QuizAnswerRequestSerializer(ModelSerializer):
      response = CharField(required=False, max_length=255, help_text="The user's response")
      correct = BooleanField(required=False, help_text="The user's self-evaluation of their response")

      def __init__(self, instance=None, data=empty, **kwargs):

          assert isinstance(instance, UserFlashcardQuiz) or instance is None

          super(QuizAnswerRequestSerializer, self).__init__(instance=instance, data=data, **kwargs)

  
      def validate_response(self, response):
          if response is None:
              return ""
          return response
  
      def validate(self, attrs):
          if not any(i in attrs for i in ('correct', 'response')):
              raise serializers.ValidationError("No data passed in")
          if 'response' in attrs and self.instance.response is not None:
              raise serializers.ValidationError("You have already sent in a response for this quiz")
          if 'correct' in attrs:
              if 'response' not in attrs and self.instance.response is None:
                  raise serializers.ValidationError("You haven't sent in a response yet")
              if self.instance.correct is not None:
                  raise serializers.ValidationError("You have already sent in the user's evaluation")
          return attrs
  
      class Meta:
          model = UserFlashcardQuiz
          exclude = 'blanked_word', 'user_flashcard', 'when'

  
  
  class SubscribeViewSerializer(Serializer):

      registration_id = CharField(allow_blank=False, allow_null=False)