import random
from unittest.mock import patch

from django.contrib.auth.models import User
from django.core import mail
from django.http import HttpResponseRedirect
from django.template.loader import render_to_string
from django.test import TestCase, Client
from django.urls import reverse, reverse_lazy
from django.utils import translation

import access_controller.settings as sets
from main.zendesk_admin import zenpy


class RegistrationTestCase(TestCase):
    fixtures = ['fixtures/data.json']

    def setUp(self):
        self.email_backend = 'django.core.mail.backends.locmem.EmailBackend'
        self.any_zendesk_user_email = 'idar.sokurov.05@mail.ru'
        self.zendesk_admin_email = 'idar.sokurov.05@mail.ru'
        self.client = Client()

    def test_registration_complete_redirect(self):
        with self.settings(EMAIL_BACKEND=self.email_backend):
            resp = self.client.post(reverse('registration'), data={'email': self.any_zendesk_user_email})
        self.assertRedirects(resp, reverse('password_reset_done'))

    def test_registration_fail_redirect(self):
        with self.settings(EMAIL_BACKEND=self.email_backend):
            resp = self.client.post(reverse('registration'), data={'email': self.any_zendesk_user_email + 'asd'})
        self.assertRedirects(resp, reverse('django_registration_disallowed'))

    def test_registration_user_already_exist(self):
        with self.settings(EMAIL_BACKEND=self.email_backend) and translation.override('ru'):
            resp = self.client.post(reverse('registration'), data={'email': '123@test.ru'})
        self.assertContains(resp, 'Этот адрес электронной почты уже используется', count=1, status_code=200)

    def test_registration_send_email(self):
        with self.settings(EMAIL_BACKEND=self.email_backend):
            response: HttpResponseRedirect = \
                self.client.post(reverse('registration'), data={'email': self.any_zendesk_user_email})
        self.assertEqual(response.status_code, 302)
        self.assertEqual(len(mail.outbox), 1)
        self.assertEqual(mail.outbox[0].to, [self.zendesk_admin_email])

        # context that the email template was rendered with
        email_context = response.context[0].dicts[1]
        correct_subject = render_to_string('registration/password_reset_subject.txt', email_context, response.request)
        self.assertEqual(mail.outbox[0].subject, correct_subject.strip())
        correct_body = render_to_string('registration/password_reset_email.html', email_context, response.request)
        self.assertEqual(mail.outbox[0].body, correct_body)

    def test_registration_user_creating(self):
        with self.settings(EMAIL_BACKEND=self.email_backend):
            self.client.post(reverse('registration'), data={'email': self.any_zendesk_user_email})
        user = User.objects.get(email=self.any_zendesk_user_email)
        zendesk_user = zenpy.get_user(self.any_zendesk_user_email)
        self.assertEqual(user.userprofile.name, zendesk_user.name)

    def test_permissions_applying(self):
        with self.settings(EMAIL_BACKEND=self.email_backend):
            self.client.post(reverse('registration'), data={'email': self.zendesk_admin_email})
        user = User.objects.get(email=self.zendesk_admin_email)
        self.assertEqual(user.userprofile.role, 'admin')
        self.assertTrue(user.has_perm('main.has_control_access'))


class MakeEngineerTestCase(TestCase):
    fixtures = ['fixtures/test_make_engineer.json']

    def setUp(self):
        self.light_agent = '123@test.ru'
        self.admin = 'admin@gmail.com'
        self.engineer = 'customer@example.com'
        self.client = Client()
        self.client.force_login(User.objects.get(email=self.light_agent))
        self.admin_client = Client()
        self.admin_client.force_login(User.objects.get(email=self.admin))

    @patch('main.extra_func.zenpy')
    def test_redirect(self, ZenpyMock):
        user = User.objects.get(email=self.light_agent)
        resp = self.client.post(reverse_lazy('work_become_engineer'))
        self.assertRedirects(resp, reverse('work', args=[user.id]))
        self.assertEqual(resp.status_code, 302)

    @patch('main.extra_func.zenpy')
    def test_light_agent_make_engineer(self, ZenpyMock):
        self.client.post(reverse_lazy('work_become_engineer'))
        self.assertEqual(ZenpyMock.update_user.call_args[0][0].custom_role_id, sets.ZENDESK_ROLES['engineer'])

    @patch('main.extra_func.zenpy')
    def test_admin_make_engineer(self, ZenpyMock):
        self.admin_client.post(reverse_lazy('work_become_engineer'))
        self.assertEqual(ZenpyMock.update_user.call_args[0][0].custom_role_id, sets.ZENDESK_ROLES['engineer'])

    @patch('main.extra_func.zenpy')
    def test_engineer_make_engineer(self, ZenpyMock):
        client = Client()
        client.force_login(User.objects.get(email=self.engineer))
        client.post(reverse_lazy('work_become_engineer'))
        self.assertEqual(ZenpyMock.update_user.call_args[0][0].custom_role_id, sets.ZENDESK_ROLES['engineer'])

    @patch('main.extra_func.zenpy')
    def test_control_page_make_one(self, ZenpyMock):
        self.admin_client.post(
            reverse_lazy('control'),
            data={'users': [User.objects.get(email=self.light_agent).userprofile.id], 'engineer': 'engineer'}
        )
        call_list = ZenpyMock.update_user.call_args_list
        mock_object = call_list[0][0][0]
        self.assertEqual(len(call_list), 1)
        self.assertEqual(mock_object.custom_role_id, sets.ZENDESK_ROLES['engineer'])

    @patch('main.extra_func.zenpy')
    def test_control_page_make_many(self, ZenpyMock):
        self.admin_client.post(
            reverse_lazy('control'),
            data={
                'users': [
                    User.objects.get(email=self.light_agent).userprofile.id,
                    User.objects.get(email=self.engineer).userprofile.id,
                ],
                'engineer': 'engineer'
            }
        )
        call_list = ZenpyMock.update_user.call_args_list
        mock_objects = list(call_list)
        self.assertEqual(len(call_list), 2)
        for obj in mock_objects:
            self.assertEqual(obj[0][0].custom_role_id, sets.ZENDESK_ROLES['engineer'])


class PasswordResetTestCase(TestCase):
    fixtures = ['fixtures/test_make_engineer.json']

    def setUp(self):
        self.user = '123@test.ru'
        self.email_backend = 'django.core.mail.backends.locmem.EmailBackend'
        self.client = Client()
        self.client.force_login(User.objects.get(email=self.user))

    def test_redirect(self):
        with self.settings(EMAIL_BACKEND=self.email_backend):
            resp = self.client.post(reverse_lazy('password_reset'), data={'email': self.user})
        self.assertRedirects(resp, reverse('password_reset_done'))
        self.assertEqual(resp.status_code, 302)

    def test_send_email(self):
        with self.settings(EMAIL_BACKEND=self.email_backend):
            response: HttpResponseRedirect = \
                self.client.post(reverse_lazy('password_reset'), data={'email': self.user})
        self.assertEqual(response.status_code, 302)
        self.assertEqual(len(mail.outbox), 1)
        self.assertEqual(mail.outbox[0].to, [self.user])

        # context that the email template was rendered with
        email_context = response.context[0].dicts[1]
        correct_subject = render_to_string('registration/password_reset_subject.txt', email_context, response.request)
        self.assertEqual(mail.outbox[0].subject, correct_subject.strip())
        correct_body = render_to_string('registration/password_reset_email.html', email_context, response.request)
        self.assertEqual(mail.outbox[0].body, correct_body)

    def test_email_invalid(self):
        with self.settings(EMAIL_BACKEND=self.email_backend) and translation.override('ru'):
            resp = self.client.post(reverse_lazy('password_reset'), data={'email': 1})
        self.assertContains(resp, 'Введите правильный адрес электронной почты.', count=1, status_code=200)

    def test_user_does_not_exist(self):
        with self.settings(EMAIL_BACKEND=self.email_backend):
            resp = self.client.post(reverse_lazy('password_reset'), data={'email': self.user + str(random.random())})
        self.assertRedirects(resp, reverse('password_reset_done'))
        self.assertEqual(resp.status_code, 302)
        self.assertEqual(len(mail.outbox), 0)


class PasswordChangeTestCase(TestCase):
    fixtures = ['fixtures/test_make_engineer.json']

    def setUp(self):
        self.user = '123@test.ru'
        self.client = Client()
        self.client.force_login(User.objects.get(email=self.user))
        self.set_password()

    def set_password(self):
        user: User = User.objects.get(email=self.user)
        user.set_password('ImpossiblyHardPassword')
        user.save()
        self.client.force_login(User.objects.get(email=self.user))

    def test_change_successful(self):
        self.client.post(
            reverse_lazy('password_change'),
            data={
                'old_password': 'ImpossiblyHardPassword',
                'new_password1': 'EasyPassword',
                'new_password2': 'EasyPassword',
            }
        )
        user = User.objects.get(email=self.user)
        self.assertTrue(user.check_password('EasyPassword'))

    def test_invalid_old_password(self):
        with translation.override('ru'):
            resp = self.client.post(
                reverse_lazy('password_change'),
                data={
                    'old_password': 'EasyPassword',
                    'new_password1': 'EasyPassword',
                    'new_password2': 'EasyPassword',
                }
            )
        self.assertContains(resp, 'Ваш старый пароль введен неправильно', count=1, status_code=200)

    def test_different_new_passwords(self):
        with translation.override('ru'):
            resp = self.client.post(
                reverse_lazy('password_change'),
                data={
                    'old_password': 'ImpossiblyHardPassword',
                    'new_password1': 'EasyPassword',
                    'new_password2': 'EasyPassword1',
                }
            )
        self.assertContains(resp, 'Введенные пароли не совпадают', count=1, status_code=200)

    def test_invalid_new_password1(self):
        with translation.override('ru'):
            resp = self.client.post(
                reverse_lazy('password_change'),
                data={
                    'old_password': 'ImpossiblyHardPassword',
                    'new_password1': 'short',
                    'new_password2': 'short',
                }
            )
        self.assertContains(resp, 'Введённый пароль слишком короткий', count=1, status_code=200)

    def test_invalid_new_password2(self):
        with translation.override('ru'):
            resp = self.client.post(
                reverse_lazy('password_change'),
                data={
                    'old_password': 'ImpossiblyHardPassword',
                    'new_password1': '123123123123123123132123123',
                    'new_password2': '123123123123123123132123123',
                }
            )
        self.assertContains(resp, 'Введённый пароль состоит только из цифр', count=1, status_code=200)

    def test_invalid_new_password3(self):
        with translation.override('ru'):
            resp = self.client.post(
                reverse_lazy('password_change'),
                data={
                    'old_password': 'ImpossiblyHardPassword',
                    'new_password1': self.user,
                    'new_password2': self.user,
                }
            )
        self.assertContains(resp, 'Введённый пароль слишком похож на имя пользователя', count=1, status_code=200)