# -*- coding: utf-8 -*-

from django.core.urlresolvers import reverse
from django.test import TestCase

from student.tests.factories import UserFactory

from fun.tests.utils import skipUnlessLms, skipUnlessCms

from ..models import TermsAndConditions, UserAcceptance, PAYMENT_TERMS

from factories import TermsAndConditionsFactory, TranslatedTermsFactory


@skipUnlessLms
class TermsAndConditionTest(TestCase):
    def setUp(self):
        """
        Create 2 kinds of terms and condition, one in 2 versions
        """
        self.user = UserFactory()
        self.terms1v10 = TermsAndConditionsFactory(name='test1', version='1.0',
                text=u"https://xkcd.com/501/")
        self.terms1v11 = TermsAndConditionsFactory(name='test1', version='1.1',
                text=self.terms1v10.text)
        self.terms2v10 = TermsAndConditionsFactory(name='test2', version='1.0',
                text=self.terms1v10.text)

    def test_get_latest(self):
        """
        Latest version of `test1` should be 1.1
        """
        terms = TermsAndConditions.get_latest(name='test1')
        self.assertEqual('1.1', terms.version)

    def test_user_never_accepted(self):
        """
        Rest what version of terms earch user should be asked to accept.
        """
        # User should have to accept the newer one of `test1`
        terms = TermsAndConditions.user_has_to_accept_new_version(
                name='test1', user=self.user)
        self.assertEqual(self.terms1v11, terms)

        # User should have to accept the only one of `test2`
        terms = TermsAndConditions.user_has_to_accept_new_version(
                name='test2', user=self.user)
        self.assertEqual(self.terms2v10, terms)

        # User do not have to accept a non existent terms
        terms = TermsAndConditions.user_has_to_accept_new_version(
                name='non-existent', user=self.user)
        self.assertEqual(False, terms)

    def test_user_accept_terms(self):
        """
        Test that user who alrady accepted terms do not need to do it again
        """
        # User has to accept latest of `test1`
        terms = TermsAndConditions.user_has_to_accept_new_version(
                name='test1', user=self.user)
        # OK then
        result = terms.accept(user=self.user)
        self.assertEqual(True, result)
        # You can not accept 2 times
        result = terms.accept(user=self.user)
        self.assertEqual(False, result)  # already accepted this version

        # what version of `test1`does user have to accept ?
        terms = TermsAndConditions.user_has_to_accept_new_version(
                name='test1', user=self.user)
        self.assertEqual(False, result)  # already accepted latest

    def test_user_has_already_acccepted(self):
        """
        Test that user_has_to_accept_new_version returns False if user already accepted latest
        """
        UserAcceptance.objects.create(user=self.user, terms=self.terms1v11)
        terms = TermsAndConditions.user_has_to_accept_new_version(
                name='test1', user=self.user)
        self.assertEqual(False, terms)

    def test_version_zero(self):
        """
        If a terms has a version 0 we want to considere it as automaticaly accepted.
        """
        TermsAndConditions.objects.create(name='test3', version='0',
                text=u"https://xkcd.com/501/")
        terms = TermsAndConditions.user_has_to_accept_new_version(
                name='test3', user=self.user)
        self.assertEqual(False, terms)


class TermsAndConditionViewsTest(TestCase):
    """
    Create FUN terms and condition, and validate user forced acceptance
    """
    def setUp(self):
        self.user = UserFactory()
        self.terms1v10 = TermsAndConditionsFactory(name=PAYMENT_TERMS, version='1.0',
                text=u"https://xkcd.com/501/")

    @skipUnlessLms
    def test_forced_acceptation(self):
        """
        User should be redirected to terms page until he accepted
        """
        self.client.login(username=self.user.username, password='test')
        # attempt to acces dashboard when still having to accept terms
        response = self.client.get(reverse("dashboard"))
        # should be redirected to acceptance page
        self.assertRedirects(response, reverse("payment:terms-page"))
        # accept then
        response = self.client.post(reverse("payment:accept-terms"))
        # and should be redirected to dashbord
        self.assertRedirects(response, reverse("dashboard"))