# -*- coding: utf-8 -*-
#
# ITerativ GmbH
# http://www.iterativ.ch/
#
# Copyright (c) 2019 ITerativ GmbH. All rights reserved.
#
# Created on 2019-10-08
# @author: chrigu <christian.cueni@iterativ.ch>
from django.core import mail
from django.contrib.sessions.middleware import SessionMiddleware
from django.test import TestCase, RequestFactory
from graphene.test import Client

from api.schema import schema
from registration.factories import LicenseTypeFactory, LicenseFactory
from registration.models import License
from users.managers import RoleManager
from users.models import Role, User, UserRole, SchoolClass


class RegistrationTests(TestCase):
    def setUp(self):

        self.teacher_role = Role.objects.create(key=Role.objects.TEACHER_KEY, name="Teacher Role")
        self.student_role = Role.objects.create(key=Role.objects.STUDENT_KEY, name="Student Role")

        self.teacher_license_type = LicenseTypeFactory(for_role=self.teacher_role)
        self.student_license_type = LicenseTypeFactory(for_role=self.student_role)

        self.teacher_license = LicenseFactory(license_type=self.teacher_license_type)
        self.student_license = LicenseFactory(license_type=self.student_license_type)

        request = RequestFactory().post('/')

        self.email = 'sepp@skillbox.iterativ.ch'
        self.first_name = 'Sepp'
        self.last_name = 'Feuz'

        # adding session
        middleware = SessionMiddleware()
        middleware.process_request(request)
        request.session.save()
        self.client = Client(schema=schema, context_value=request)

    def make_register_mutation(self, first_name, last_name, email, license_key):
        mutation = '''
            mutation Registration($input: RegistrationInput!){
              registration(input: $input) {
                success
                errors {
                  field
                }
              }
            }
        '''

        return self.client.execute(mutation, variables={
            'input': {
                'firstnameInput': first_name,
                'lastnameInput': last_name,
                'emailInput': email,
                'licenseKeyInput': license_key,
            }
        })

    def _assert_user_registration(self, count, email, role_key):
        users = User.objects.filter(username=self.email)
        self.assertEqual(len(users), count)
        user_roles = UserRole.objects.filter(user__email=email, role__key=role_key)
        self.assertEqual(len(user_roles), count)
        licenses = License.objects.filter(licensee__email=email, license_type__for_role__key=role_key)
        self.assertEqual(len(licenses), count)

    def test_user_can_register_as_teacher(self):
        self._assert_user_registration(0, self.email, RoleManager.TEACHER_KEY)
        school_classes = SchoolClass.objects.filter(name__startswith='Meine Klasse')
        self.assertEqual(len(school_classes), 0)
        result = self.make_register_mutation(self.first_name, self.last_name, self.email, self.teacher_license_type.key)
        self.assertTrue(result.get('data').get('registration').get('success'))
        self._assert_user_registration(1, self.email, RoleManager.TEACHER_KEY)
        school_classes = SchoolClass.objects.filter(name__startswith='Meine Klasse')
        self.assertEqual(len(school_classes), 1)
        user = User.objects.get(email=self.email)
        self.assertTrue(school_classes[0].is_user_in_schoolclass(user))
        self.assertEqual(len(mail.outbox), 1)
        self.assertEqual(mail.outbox[0].subject, 'Myskillbox: E-Mail bestätigen und Passwort setzen')

    def test_user_can_register_as_student(self):
        self._assert_user_registration(0, self.email, RoleManager.STUDENT_KEY)
        result = self.make_register_mutation(self.first_name, self.last_name, self.email, self.student_license_type.key)
        self.assertTrue(result.get('data').get('registration').get('success'))
        self._assert_user_registration(1, self.email, RoleManager.STUDENT_KEY)

    def test_existing_user_cannot_register(self):
        self._assert_user_registration(0, self.email, RoleManager.STUDENT_KEY)
        self.make_register_mutation(self.first_name, self.last_name, self.email, self.student_license_type.key)
        result = self.make_register_mutation(self.first_name, self.last_name, self.email, self.student_license_type.key)
        self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'email')

    def test_existing_user_cannot_register_with_uppercase_email(self):
        self._assert_user_registration(0, self.email, RoleManager.STUDENT_KEY)
        self.make_register_mutation(self.first_name, self.last_name, self.email.upper(), self.student_license_type.key)
        result = self.make_register_mutation(self.first_name, self.last_name, self.email, self.student_license_type.key)
        self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'email')

    def test_user_cannot_register_if_firstname_is_missing(self):
        result = self.make_register_mutation('', self.last_name, self.email, self.teacher_license_type.key)
        self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'first_name')
        self.assertFalse(result.get('data').get('registration').get('success'))

    def test_user_cannot_register_if_lastname_is_missing(self):
        result = self.make_register_mutation(self.first_name, '', self.email, self.teacher_license_type.key)
        self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'last_name')
        self.assertFalse(result.get('data').get('registration').get('success'))

    def test_user_cannot_register_if_email_is_missing(self):
        result = self.make_register_mutation(self.first_name, self.last_name, '', self.teacher_license_type.key)
        self.assertEqual(result.get('data').get('registration').get('errors')[0].get('field'), 'email')
        self.assertFalse(result.get('data').get('registration').get('success'))