from django.core import mail
from flashcards.models import *
from rest_framework.status import HTTP_204_NO_CONTENT, HTTP_201_CREATED, HTTP_200_OK, HTTP_403_FORBIDDEN
from rest_framework.test import APITestCase
from re import search
from django.utils.timezone import now


class LoginTests(APITestCase):
    fixtures = ['testusers']

    def test_login(self):
        url = '/api/login'
        data = {'email': 'none@none.com', 'password': '1234'}
        response = self.client.post(url, data, format='json')
        self.assertEqual(response.status_code, HTTP_200_OK)

        data = {'email': 'none@none.com', 'password': '4321'}
        response = self.client.post(url, data, format='json')
        self.assertContains(response, 'Invalid email or password', status_code=403)

        data = {'email': 'bad@none.com', 'password': '1234'}
        response = self.client.post(url, data, format='json')
        self.assertContains(response, 'Invalid email or password', status_code=403)

        data = {'password': '4321'}
        response = self.client.post(url, data, format='json')
        self.assertContains(response, 'email', status_code=400)

        data = {'email': 'none@none.com'}
        response = self.client.post(url, data, format='json')
        self.assertContains(response, 'password', status_code=400)

        user = User.objects.get(email="none@none.com")
        user.is_active = False
        user.save()

        data = {'email': 'none@none.com', 'password': '1234'}
        response = self.client.post(url, data, format='json')
        self.assertContains(response, 'Account is disabled', status_code=403)

    def test_logout(self):
        self.client.login(email='none@none.com', password='1234')
        response = self.client.post('/api/logout')
        self.assertEqual(response.status_code, HTTP_204_NO_CONTENT)

        # since we're not logged in, we should get a 403 response
        response = self.client.get('/api/me', format='json')
        self.assertEqual(response.status_code, HTTP_403_FORBIDDEN)


class PasswordResetTest(APITestCase):
    fixtures = ['testusers']

    def test_reset_password(self):
        # submit the request to reset the password
        url = '/api/request_password_reset'
        post_data = {'email': 'none@none.com'}
        self.client.post(url, post_data, format='json')
        self.assertEqual(len(mail.outbox), 1)
        self.assertIn('reset your password', mail.outbox[0].body)

        # capture the reset token from the email
        capture = search('https://flashy.cards/app/resetpassword/(\d+)/(.*)',
                         mail.outbox[0].body)
        patch_data = {'new_password': '4321'}
        patch_data['uid'] = capture.group(1)
        reset_token = capture.group(2)

        # try to reset the password with the wrong reset token
        patch_data['token'] = 'wrong_token'
        url = '/api/reset_password'
        response = self.client.post(url, patch_data, format='json')
        self.assertContains(response, 'Could not verify reset token', status_code=400)

        # try to reset the password with the correct token
        patch_data['token'] = reset_token
        response = self.client.post(url, patch_data, format='json')
        self.assertEqual(response.status_code, HTTP_204_NO_CONTENT)
        user = User.objects.get(id=patch_data['uid'])
        assert user.check_password(patch_data['new_password'])


class RegistrationTest(APITestCase):
    def test_create_account(self):
        url = '/api/register'

        # missing password
        data = {'email': 'none@none.com'}
        response = self.client.post(url, data, format='json')
        self.assertContains(response, 'password', status_code=400)

        # missing email
        data = {'password': '1234'}
        response = self.client.post(url, data, format='json')
        self.assertContains(response, 'email', status_code=400)

        # create a user
        data = {'email': 'none@none.com', 'password': '1234'}
        response = self.client.post(url, data, format='json')
        self.assertEqual(response.status_code, HTTP_201_CREATED)

        # user should not be confirmed
        user = User.objects.get(email="none@none.com")
        self.assertFalse(user.is_confirmed)

        # check that the confirmation key was sent
        self.assertEqual(len(mail.outbox), 1)
        self.assertIn(user.confirmation_key, mail.outbox[0].body)

        # log the user out
        self.client.logout()

        # log the user in with their registered credentials
        self.client.login(email='none@none.com', password='1234')

        # try activating with an invalid key

        url = '/api/me'
        response = self.client.patch(url, {'confirmation_key': 'NOT A KEY'})
        self.assertContains(response, 'confirmation_key is invalid', status_code=400)

        # try activating with the valid key
        response = self.client.patch(url, {'confirmation_key': user.confirmation_key})
        self.assertTrue(response.data['is_confirmed'])


class ProfileViewTest(APITestCase):
    fixtures = ['testusers']

    def test_get_me(self):
        url = '/api/me'
        response = self.client.get(url, format='json')
        # since we're not logged in, we shouldn't be able to see this
        self.assertEqual(response.status_code, 403)

        self.client.login(email='none@none.com', password='1234')
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, HTTP_200_OK)


class PasswordChangeTest(APITestCase):
    fixtures = ['testusers']

    def test_change_password(self):
        url = '/api/me'
        user = User.objects.get(email='none@none.com')
        self.assertTrue(user.check_password('1234'))

        response = self.client.patch(url, {'new_password': '4321', 'old_password': '1234'}, format='json')
        self.assertEqual(response.status_code, HTTP_403_FORBIDDEN)

        self.client.login(email='none@none.com', password='1234')
        response = self.client.patch(url, {'new_password': '4321'}, format='json')
        self.assertContains(response, 'old_password is required', status_code=400)

        response = self.client.patch(url, {'new_password': '4321', 'old_password': '4321'}, format='json')
        self.assertContains(response, 'old_password is incorrect', status_code=400)

        response = self.client.patch(url, {'new_password': '4321', 'old_password': '1234'}, format='json')
        self.assertEqual(response.status_code, 200)
        user = User.objects.get(email='none@none.com')

        self.assertFalse(user.check_password('1234'))
        self.assertTrue(user.check_password('4321'))


class DeleteUserTest(APITestCase):
    fixtures = ['testusers']

    def test_delete_user(self):
        url = '/api/me'
        user = User.objects.get(email='none@none.com')

        self.client.login(email='none@none.com', password='1234')
        self.client.delete(url)
        self.assertFalse(User.objects.filter(email='none@none.com').exists())


class FlashcardDetailTest(APITestCase):
    fixtures = ['testusers', 'testsections']

    def setUp(self):
        section = Section.objects.get(pk=1)
        user = User.objects.get(email='none@none.com')
        section.enroll(user)
        self.inaccessible_flashcard = Flashcard(text="you can't see me!", section=Section.objects.get(pk=2),
                                                material_date=now(), author=user)
        self.inaccessible_flashcard.save()
        self.flashcard = Flashcard(text="jason", section=section, material_date=now(), author=user)
        self.flashcard.save()

    def test_edit_flashcard(self):
        self.client.login(email='none@none.com', password='1234')
        user = User.objects.get(email='none@none.com')
        user.sections.add(Section.objects.get(pk=1))
        user.save()

    def test_create_flashcard(self):
        self.client.login(email='none@none.com', password='1234')
        user = User.objects.get(email='none@none.com')
        user.sections.add(Section.objects.get(pk=1))
        user.save()
        data = {'text': 'this is a flashcard',
                'material_date': now(),
                'mask': '[]',
                'section': '1',
                'previous': None}
        response = self.client.post("/api/flashcards/", data, format="json")
        self.assertEqual(response.status_code, HTTP_201_CREATED)
        self.assertEqual(response.data['text'], data['text'])
        self.assertTrue(Flashcard.objects.filter(section__pk=1, text=data['text']).exists())

    def test_get_flashcard(self):
        self.client.login(email='none@none.com', password='1234')
        response = self.client.get("/api/flashcards/%d/" % self.flashcard.id, format="json")
        self.assertEqual(response.status_code, HTTP_200_OK)
        self.assertEqual(response.data["text"], "jason")


class SectionViewSetTest(APITestCase):
    fixtures = ['testusers', 'testsections']

    def setUp(self):
        self.client.login(email='none@none.com', password='1234')
        self.user = User.objects.get(email='none@none.com')
        self.flashcard = Flashcard(text="jason", section=Section.objects.get(pk=1), material_date=now(),
                                   author=self.user)
        self.flashcard.save()
        self.section = Section.objects.get(pk=1)

    def test_list_sections(self):
        response = self.client.get("/api/sections/", format="json")
        self.assertEqual(response.status_code, HTTP_200_OK)

    def test_section_enroll(self):
        section = self.section
        self.assertFalse(self.user.sections.filter(pk=section.pk))

        # test enrolling in a section without a whitelist
        response = self.client.post('/api/sections/%d/enroll/' % section.pk)
        self.assertEqual(response.status_code, HTTP_204_NO_CONTENT)
        self.assertTrue(self.user.sections.filter(pk=section.pk).exists())

        section = Section.objects.get(pk=2)
        WhitelistedAddress.objects.create(email='bad@none.com', section=section)

        # test enrolling in a section when not on the whitelist
        response = self.client.post('/api/sections/%d/enroll/' % section.pk)
        self.assertEqual(response.status_code, HTTP_403_FORBIDDEN)
        self.assertFalse(self.user.sections.filter(pk=section.pk).exists())

        WhitelistedAddress.objects.create(email=self.user.email, section=section)

        # test enrolling in a section when on the whitelist
        response = self.client.post('/api/sections/%d/enroll/' % section.pk)
        self.assertEqual(response.status_code, HTTP_204_NO_CONTENT)
        self.assertTrue(self.user.sections.filter(pk=section.pk).exists())

    def test_section_drop(self):
        section = self.section

        # test dropping a section that the user isn't in
        response = self.client.post('/api/sections/%d/drop/' % section.pk)
        self.assertEqual(response.status_code, 400)

        self.user.sections.add(section)
        self.assertTrue(self.user.sections.filter(pk=section.pk).exists())

        # test dropping a section that the user is in
        response = self.client.post('/api/sections/%d/drop/' % section.pk)
        self.assertEqual(response.status_code, HTTP_204_NO_CONTENT)
        self.assertFalse(self.user.sections.filter(pk=section.pk).exists())

    def test_section_flashcards(self):
        # test to get flashcards for section 1
        response = self.client.get('/api/sections/1/flashcards/')
        self.assertEqual(response.status_code, HTTP_200_OK)

        # test: Making FlashcardHide object, so no card should be seen.
        flashcard_hide = FlashcardHide(user=self.user, flashcard=self.flashcard)
        flashcard_hide.save()
        response = self.client.get('/api/sections/1/flashcards/')
        self.assertEqual(response.status_code, HTTP_200_OK)
        self.assertEqual(response.content, '[]')

    def test_section_search(self):
        response = self.client.get('/api/sections/search/?q=Kramer')
        self.assertEqual(response.status_code, HTTP_200_OK)

    def test_section_deck(self):
        self.user.sections.add(self.section)
        self.user.save()
        response = self.client.get('/api/sections/1/deck/')
        self.assertEqual(response.status_code, HTTP_200_OK)

    def test_section_feed(self):
        response = self.client.get('/api/sections/1/feed/')
        self.assertEqual(response.status_code, HTTP_200_OK)
        self.assertEqual(response.data[0]['id'], 1)

    def test_section_ordered_deck(self):
        self.user.sections.add(self.section)
        self.user.save()
        response = self.client.get('/api/sections/1/ordered_deck/')
        self.assertEqual(response.status_code, HTTP_200_OK)


class FlashcardViewSetTest(APITestCase):
    fixtures = ['testusers', 'testsections']

    def setUp(self):
        self.client.login(email='none@none.com', password='1234')
        self.user = User.objects.get(email='none@none.com')
        self.section = Section.objects.get(pk=1)
        self.section.enroll(self.user)
        self.flashcard = Flashcard(text="jason", section=self.section, material_date=now(),
                                   author=self.user)
        self.flashcard.save()
        self.inaccessible_flashcard = Flashcard(text="can't touch this", section=Section.objects.get(pk=2),
                                                material_date=now(), author=self.user)
        self.inaccessible_flashcard.save()


    def test_hide_flashcard(self):
        url = '/api/flashcards/1/hide/'
        response = self.client.post(url, format='json')
        self.assertEqual(response.status_code, HTTP_204_NO_CONTENT)

        response = self.client.post('/api/flashcards/%d/hide/' % self.inaccessible_flashcard.pk, format='json')
        # This should fail because the user is not enrolled in section id 2
        self.assertEqual(response.status_code, HTTP_403_FORBIDDEN)

    def test_unhide_flashcard(self):
        url = '/api/flashcards/1/unhide/'
        flashcard_hide = FlashcardHide(user=self.user, flashcard=self.flashcard)
        flashcard_hide.save()

        response = self.client.post(url, format='json')
        self.assertEqual(response.status_code, HTTP_204_NO_CONTENT)

        response = self.client.post('/api/flashcards/%d/unhide/' % self.inaccessible_flashcard.pk, format='json')

        # This should fail because the user is not enrolled in section id 2
        self.assertEqual(response.status_code, HTTP_403_FORBIDDEN)