# -*- coding: utf-8 -*-
from __future__ import print_function, unicode_literals, division, absolute_import

import socketio

from django.db.models import F
from django.conf import settings
from django.utils import timezone
from django.template.defaultfilters import date as date_filter

from rest_framework import serializers

from sk_auth.audit import get_client_ip
from sk_subscription.models import ActiveSubscription, SubscriptionAllergy
from sk_school.models import School, Student, Employee
from sk_kiosk.models import KioskCheckIn
from sk_kiosk.exceptions import KioskCheckInException

class LoginSerializer(serializers.Serializer):
    """
        Inntak þegar skóli er að skrá sig inn.
    """
    username = serializers.CharField(required=True, allow_blank=False)
    password = serializers.CharField(required=True, allow_blank=False)

    def validate_username(self, value):
        try:
            school = School.objects.filter(pin__isnull=False).get(uuid=value)

            return school
        except School.DoesNotExist:
            raise serializers.ValidationError('Skóli er ekki til.')

    def validate(self, data):
        school = data.get('username')
        pin = data.get('password')

        if school.pin_locked is not None and school.pin_locked > timezone.now():
            raise serializers.ValidationError('Of margar tilraunir. Vinsamlegast reyndu aftur eftir {}.'.format(date_filter(school.pin_locked, 'j. F Y H:i')))

        if str(school.pin) != pin:
            if school.pin_attempt > 3:
                pin_locked = timezone.now() + timezone.timedelta(minutes=5)
                School.objects.filter(pk=school.pk).update(pin_attempt=F('pin_attempt') + 1, pin_locked=pin_locked)
                raise serializers.ValidationError('Lykilorð er ekki rétt. Of margar tilraunir. Vinsamlegast reyndu aftur eftir {}.'.format(date_filter(pin_locked, 'j. F Y H:i')))
            else:
                School.objects.filter(pk=school.pk).update(pin_attempt=F('pin_attempt') + 1)
                raise serializers.ValidationError('Lykilorð er ekki rétt. Vinsamlegast reyndu aftur.')

        return data


    def create(self, validated_data):
        school = validated_data.get('username')

        School.objects.filter(pk=school.pk).update(pin_attempt=0, pin_locked=None)

        return school


class CheckInSerializer(serializers.Serializer):
    """
        Inntak þegar nemandi eða starfsmaður er að skrá sig í mat.
    """
    pin = serializers.CharField(required=True, allow_blank=False)

    def validate_pin(self, data):
        try:
            student = Student.objects.only('id', 'uuid', 'ssn', 'name', ).get(pin=data)
            return dict(is_student=True, is_employee=False, student=student)
        except Student.DoesNotExist:
            pass

        try:
            employee = Employee.objects.only('id', 'uuid', 'ssn', 'name', ).get(pin=data)
            return dict(is_student=False, is_employee=True, employee=employee)
        except Employee.DoesNotExist:
            pass

        return dict(is_employee=False, is_student=False, pin=data)

    def validate(self, data):
        student_or_employee = data['pin']

        if not student_or_employee['is_student'] and not student_or_employee['is_employee']:
            external_sio = socketio.KombuManager(settings.KIOSK_MESSAGE_QUEUE, channel='kiosk-socketio', write_only=True)
            external_sio.emit('checkin-error', data={
                'name': None,
                'detail': 'PIN númer ekki til.',
                'code': 'invalid_pin',
            }, namespace='/kiosk', room=str(self.context['school'].uuid))
            raise KioskCheckInException(name=None, detail='PIN númer ekki til.', code='invalid_pin')

        is_student = False
        is_employee = False
        employee = None
        student = None

        if 'is_student' in student_or_employee and student_or_employee['is_student']:
            is_student = True
            student = student_or_employee['student']
        elif 'is_employee' in student_or_employee and student_or_employee['is_employee']:
            is_employee = True
            employee = student_or_employee['employee']

        active_subscription_queryset = ActiveSubscription.objects.all()

        active_subscription_queryset = active_subscription_queryset.select_related('subscription')
        active_subscription_queryset = active_subscription_queryset.only(
            'id', 'uuid', 'subscription__id', 'subscription__uuid', 'subscription__allergies_other',
        )

        now = timezone.now()
        weekday = now.weekday()

        active_subscription_queryset = active_subscription_queryset.filter(school=self.context['school'])
        active_subscription_queryset = active_subscription_queryset.filter(monday=True) if weekday == 0 else active_subscription_queryset
        active_subscription_queryset = active_subscription_queryset.filter(tuesday=True) if weekday == 1 else active_subscription_queryset
        active_subscription_queryset = active_subscription_queryset.filter(wednesday=True) if weekday == 2 else active_subscription_queryset
        active_subscription_queryset = active_subscription_queryset.filter(thursday=True) if weekday == 3 else active_subscription_queryset
        active_subscription_queryset = active_subscription_queryset.filter(friday=True) if weekday == 4 else active_subscription_queryset

        if weekday > 4:
            external_sio = socketio.KombuManager(settings.KIOSK_MESSAGE_QUEUE, channel='kiosk-socketio', write_only=True)
            external_sio.emit('checkin-error', data={
                'name': None,
                'detail': 'Aðeins er hægt að skrá á virkum dögum.',
                'code': 'invalid_weekday',
            }, namespace='/kiosk', room=str(self.context['school'].uuid))
            raise KioskCheckInException(name=None, detail='Aðeins er hægt að skrá á virkum dögum.', code='invalid_weekday')

        active_subscription_queryset = active_subscription_queryset.filter(enabled=True)
        active_subscription_queryset = active_subscription_queryset.filter(valid_from__lte=now)
        active_subscription_queryset = active_subscription_queryset.filter(valid_to__gte=now)

        if is_student:
            active_subscription_queryset = active_subscription_queryset.filter(subscription__student=student)
        elif is_employee:
            active_subscription_queryset = active_subscription_queryset.filter(subscription__employee=employee)

        try:
            active_subscription = active_subscription_queryset.get()
        except ActiveSubscription.DoesNotExist:
            if is_student:
                external_sio = socketio.KombuManager(settings.KIOSK_MESSAGE_QUEUE, channel='kiosk-socketio', write_only=True)
                external_sio.emit('checkin-error', data={
                    'name': student.name,
                    'ssn': student.ssn,
                    'detail': 'Ekki í áskrift í dag.',
                    'code': 'invalid_subscription',
                }, namespace='/kiosk', room=str(self.context['school'].uuid))
                KioskCheckIn.objects.create(
                            active_subscription=None,
                            ip=get_client_ip(self.context['request']),
                            school=self.context['school'],
                            student=student,
                            employee=employee,
                            invalid=True,
                            invalid_reason='Ekki í áskrift í dag.',
                        )
                raise KioskCheckInException(name=student.name, detail='Ekki í áskrift í dag.', code='invalid_subscription')

            elif is_employee:
                external_sio = socketio.KombuManager(settings.KIOSK_MESSAGE_QUEUE, channel='kiosk-socketio', write_only=True)
                external_sio.emit('checkin-error', data={
                    'name': employee.name,
                    'ssn': employee.ssn,
                    'detail': 'Ekki í áskrift í dag.',
                    'code': 'invalid_subscription',
                }, namespace='/kiosk', room=str(self.context['school'].uuid))
                KioskCheckIn.objects.create(
                            active_subscription=None,
                            ip=get_client_ip(self.context['request']),
                            school=self.context['school'],
                            student=student,
                            employee=employee,
                            invalid=True,
                            invalid_reason='Ekki í áskrift í dag.',
                        )
                raise KioskCheckInException(name=employee.name, detail='Ekki í áskrift í dag.', code='invalid_subscription')

        data['active_subscription'] = active_subscription
        data['student'] = student
        data['employee'] = employee

        return data

    def create(self, validated_data):
        active_subscription = validated_data.get('active_subscription')

        subscription_allergy_queryset = SubscriptionAllergy.objects.filter(
            subscription_id=active_subscription.subscription_id,
            allergy__isnull=False
        )

        subscription_allergy_queryset = subscription_allergy_queryset.select_related('allergy')
        subscription_allergy_queryset = subscription_allergy_queryset.only(
            'id', 'uuid', 'allergy__id', 'allergy__uuid', 'allergy__name', 'certificate',
        )

        kiosk_checkin = KioskCheckIn.objects.create(
            active_subscription = active_subscription,
            ip=get_client_ip(self.context['request']),
            school=self.context['school'],
            student=validated_data['student'],
            employee=validated_data['employee'],
            invalid=False,
            invalid_reason=None,
        )

        # connect to the redis queue through Kombu
        external_sio = socketio.KombuManager(settings.KIOSK_MESSAGE_QUEUE, channel='kiosk-socketio', write_only=True)

        emit_data = None
        pin_data = validated_data.get('pin')
        if pin_data.get('is_student', False):
            emit_data = {
                'is_student': True,
                'is_employee': False,
                'subscription': {
                    'allergies_other': active_subscription.subscription.allergies_other,
                    'allergies': [{
                        'allergy': {
                            'name': subscription_allergy.allergy.name,
                        },
                        'certificate': True if subscription_allergy.certificate else False,
                    } for subscription_allergy in subscription_allergy_queryset]
                },
                'info': {
                    'id': str(pin_data.get('student').uuid),
                    'ssn': pin_data.get('student').ssn,
                    'name': pin_data.get('student').name,
                }
            }
        elif pin_data.get('is_employee', False):
            emit_data = {
                'is_student': False,
                'is_employee': True,
                'subscription': {
                    'allergies_other': active_subscription.subscription.allergies_other,
                    'allergies': [{
                        'allergy': {
                            'name': subscription_allergy.allergy.name,
                        },
                        'certificate': True if subscription_allergy.certificate else False,
                    } for subscription_allergy in subscription_allergy_queryset]
                },
                'info': {
                    'id': str(pin_data.get('employee').uuid),
                    'ssn': pin_data.get('employee').ssn,
                    'name': pin_data.get('employee').name,
                }
            }

        external_sio.emit('checkin', data=emit_data, namespace='/kiosk', room=str(self.context['school'].uuid))

        return emit_data