"""
Unit tests for bulk-email-related forms.
"""


from opaque_keys.edx.locator import CourseLocator

from lms.djangoapps.bulk_email.api import is_bulk_email_feature_enabled
from lms.djangoapps.bulk_email.forms import CourseAuthorizationAdminForm, CourseEmailTemplateForm
from lms.djangoapps.bulk_email.models import BulkEmailFlag, CourseEmailTemplate
from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
from xmodule.modulestore.tests.factories import CourseFactory


class CourseAuthorizationFormTest(ModuleStoreTestCase):
    """Test the CourseAuthorizationAdminForm form for Mongo-backed courses."""

    def setUp(self):
        super().setUp()
        course_title = "ẗëṡẗ title ｲ乇丂ｲ ﾶ乇丂丂ﾑg乇 ｷo尺 ﾑﾚﾚ тэѕт мэѕѕаБэ"
        self.course = CourseFactory.create(display_name=course_title)
        BulkEmailFlag.objects.create(enabled=True, require_course_email_auth=True)

    def tearDown(self):
        super().tearDown()
        BulkEmailFlag.objects.all().delete()

    def test_authorize_mongo_course(self):
        # Initially course shouldn't be authorized
        assert not is_bulk_email_feature_enabled(self.course.id)
        # Test authorizing the course, which should totally work
        form_data = {'course_id': str(self.course.id), 'email_enabled': True}
        form = CourseAuthorizationAdminForm(data=form_data)
        # Validation should work
        assert form.is_valid()
        form.save()
        # Check that this course is authorized
        assert is_bulk_email_feature_enabled(self.course.id)

    def test_repeat_course(self):
        # Initially course shouldn't be authorized
        assert not is_bulk_email_feature_enabled(self.course.id)
        # Test authorizing the course, which should totally work
        form_data = {'course_id': str(self.course.id), 'email_enabled': True}
        form = CourseAuthorizationAdminForm(data=form_data)
        # Validation should work
        assert form.is_valid()
        form.save()
        # Check that this course is authorized
        assert is_bulk_email_feature_enabled(self.course.id)

        # Now make a new course authorization with the same course id that tries to turn email off
        form_data = {'course_id': str(self.course.id), 'email_enabled': False}
        form = CourseAuthorizationAdminForm(data=form_data)
        # Validation should not work because course_id field is unique
        assert not form.is_valid()
        assert 'Course authorization with this Course id already exists.' == form._errors['course_id'][0]  # pylint: disable=protected-access, line-too-long

        with self.assertRaisesRegex(
            ValueError,
            "The CourseAuthorization could not be created because the data didn't validate."
        ):
            form.save()

        # Course should still be authorized (invalid attempt had no effect)
        assert is_bulk_email_feature_enabled(self.course.id)

    def test_form_typo(self):
        # Munge course id
        bad_id = CourseLocator(f'Broken{self.course.id.org}', 'hello', self.course.id.run + '_typo')

        form_data = {'course_id': str(bad_id), 'email_enabled': True}
        form = CourseAuthorizationAdminForm(data=form_data)
        # Validation shouldn't work
        assert not form.is_valid()

        msg = 'Course not found.'
        msg += f' Entered course id was: "{str(bad_id)}".'
        assert msg == form._errors['course_id'][0]  # pylint: disable=protected-access

        with self.assertRaisesRegex(
            ValueError,
            "The CourseAuthorization could not be created because the data didn't validate."
        ):
            form.save()

    def test_form_invalid_key(self):
        form_data = {'course_id': "asd::**!@#$%^&*())//foobar!!", 'email_enabled': True}
        form = CourseAuthorizationAdminForm(data=form_data)
        # Validation shouldn't work
        assert not form.is_valid()

        msg = 'Course id invalid.'
        msg += ' Entered course id was: "asd::**!@#$%^&*())//foobar!!".'
        assert msg == form._errors['course_id'][0]  # pylint: disable=protected-access

        with self.assertRaisesRegex(
            ValueError,
            "The CourseAuthorization could not be created because the data didn't validate."
        ):
            form.save()

    def test_course_name_only(self):
        # Munge course id - common
        form_data = {'course_id': self.course.id.run, 'email_enabled': True}
        form = CourseAuthorizationAdminForm(data=form_data)
        # Validation shouldn't work
        assert not form.is_valid()

        error_msg = form._errors['course_id'][0]  # pylint: disable=protected-access
        assert f'Entered course id was: "{self.course.id.run}".' in error_msg

        with self.assertRaisesRegex(
            ValueError,
            "The CourseAuthorization could not be created because the data didn't validate."
        ):
            form.save()


class CourseEmailTemplateFormTest(ModuleStoreTestCase):
    """Test the CourseEmailTemplateForm that is used in the Django admin subsystem."""

    def test_missing_message_body_in_html(self):
        """
        Asserts that we fail validation if we do not have the {{message_body}} tag
        in the submitted HTML template
        """
        form_data = {
            'html_template': '',
            'plain_template': '{{message_body}}',
            'name': ''
        }
        form = CourseEmailTemplateForm(form_data)
        assert not form.is_valid()

    def test_missing_message_body_in_plain(self):
        """
        Asserts that we fail validation if we do not have the {{message_body}} tag
        in the submitted plain template
        """
        form_data = {
            'html_template': '{{message_body}}',
            'plain_template': '',
            'name': ''
        }
        form = CourseEmailTemplateForm(form_data)
        assert not form.is_valid()

    def test_blank_name_is_null(self):
        """
        Asserts that submitting a CourseEmailTemplateForm with a blank name is stored
        as a NULL in the database
        """
        form_data = {
            'html_template': '{{message_body}}',
            'plain_template': '{{message_body}}',
            'name': ''
        }
        form = CourseEmailTemplateForm(form_data)
        assert form.is_valid()
        form.save()

        # now inspect the database and make sure the blank name was stored as a NULL
        # Note this will throw an exception if it is not found
        cet = CourseEmailTemplate.objects.get(name=None)
        assert cet is not None

    def test_name_with_only_spaces_is_null(self):
        """
        Asserts that submitting a CourseEmailTemplateForm just blank whitespace is stored
        as a NULL in the database
        """
        form_data = {
            'html_template': '{{message_body}}',
            'plain_template': '{{message_body}}',
            'name': '   '
        }
        form = CourseEmailTemplateForm(form_data)
        assert form.is_valid()
        form.save()

        # now inspect the database and make sure the whitespace only name was stored as a NULL
        # Note this will throw an exception if it is not found
        cet = CourseEmailTemplate.objects.get(name=None)
        assert cet is not None

    def test_name_with_spaces_is_trimmed(self):
        """
        Asserts that submitting a CourseEmailTemplateForm with a name that contains
        whitespace at the beginning or end of a name is stripped
        """
        form_data = {
            'html_template': '{{message_body}}',
            'plain_template': '{{message_body}}',
            'name': ' foo  '
        }
        form = CourseEmailTemplateForm(form_data)
        assert form.is_valid()
        form.save()

        # now inspect the database and make sure the name is properly
        # stripped
        cet = CourseEmailTemplate.objects.get(name='foo')
        assert cet is not None

    def test_non_blank_name(self):
        """
        Asserts that submitting a CourseEmailTemplateForm with a non-blank name
        can be found in the database under than name as a look-up key
        """
        form_data = {
            'html_template': '{{message_body}}',
            'plain_template': '{{message_body}}',
            'name': 'foo'
        }
        form = CourseEmailTemplateForm(form_data)
        assert form.is_valid()
        form.save()

        # now inspect the database and make sure the blank name was stored as a NULL
        # Note this will throw an exception if it is not found
        cet = CourseEmailTemplate.objects.get(name='foo')
        assert cet is not None

    def test_duplicate_name(self):
        """
        Assert that we cannot submit a CourseEmailTemplateForm with a name
        that already exists
        """

        # first set up one template
        form_data = {
            'html_template': '{{message_body}}',
            'plain_template': '{{message_body}}',
            'name': 'foo'
        }
        form = CourseEmailTemplateForm(form_data)
        assert form.is_valid()
        form.save()

        # try to submit form with the same name
        form = CourseEmailTemplateForm(form_data)
        assert not form.is_valid()

        # try again with a name with extra whitespace
        # this should fail as we strip the whitespace away
        form_data = {
            'html_template': '{{message_body}}',
            'plain_template': '{{message_body}}',
            'name': '  foo '
        }
        form = CourseEmailTemplateForm(form_data)
        assert not form.is_valid()

        # then try a different name
        form_data = {
            'html_template': '{{message_body}}',
            'plain_template': '{{message_body}}',
            'name': 'bar'
        }
        form = CourseEmailTemplateForm(form_data)
        assert form.is_valid()
        form.save()

        form = CourseEmailTemplateForm(form_data)
        assert not form.is_valid()
