import datetime
from io import BytesIO

from django.conf import settings
from django.contrib.auth.models import AnonymousUser
from django.contrib.contenttypes.models import ContentType
from django.test import RequestFactory, TestCase, override_settings
from django.urls import reverse
from django.utils.html import escape
from django.utils.http import urlencode
from openpyxl import load_workbook

from wagtail.admin.forms import WagtailAdminPageForm
from wagtail.admin.panels import get_form_for_model
from wagtail.contrib.forms.models import FormSubmission
from wagtail.contrib.forms.panels import FormSubmissionsPanel
from wagtail.contrib.forms.tests.utils import (
    make_form_page,
    make_form_page_with_custom_submission,
)
from wagtail.contrib.forms.utils import get_form_types
from wagtail.models import Locale, Page
from wagtail.test.demosite.models import FormPage as FormPageDemo
from wagtail.test.testapp.models import (
    CustomFormPageSubmission,
    ExtendedFormField,
    FormField,
    FormFieldForCustomListViewPage,
    FormFieldWithCustomSubmission,
    FormPage,
    FormPageWithCustomFormBuilder,
    FormPageWithCustomSubmission,
    FormPageWithCustomSubmissionListView,
    FormPageWithRedirect,
    JadeFormPage,
)
from wagtail.test.utils import WagtailTestUtils
from wagtail.test.utils.form_data import inline_formset, nested_form_data


class TestFormResponsesPanel(TestCase):
    def setUp(self):
        self.request = RequestFactory().get("/")
        user = AnonymousUser()  # technically, Anonymous users cannot access the admin
        self.request.user = user

        self.form_page = make_form_page()

        self.FormPageForm = get_form_for_model(
            FormPage,
            form_class=WagtailAdminPageForm,
            fields=["title", "slug", "to_address", "from_address", "subject"],
        )

        panel = FormSubmissionsPanel().bind_to_model(FormPage)
        self.panel = panel.get_bound_panel(
            instance=self.form_page, form=self.FormPageForm(), request=self.request
        )

    def test_render_with_submissions(self):
        """Show the panel with the count of submission and a link to the list_submissions view."""
        self.client.post(
            "/contact-us/",
            {
                "your_email": "bob@example.com",
                "your_message": "hello world",
                "your_choices": {"foo": "", "bar": "", "baz": ""},
            },
        )

        self.assertTrue(self.panel.is_shown())
        result = self.panel.render_html()

        url = reverse("wagtailforms:list_submissions", args=(self.form_page.id,))
        link = f'<a href="{url}">1</a>'

        self.assertIn(link, result)

    def test_render_without_submissions(self):
        """The panel should not be shown if the number of submission is zero."""
        self.assertFalse(self.panel.is_shown())


class TestFormResponsesPanelWithNewPage(TestCase):
    def setUp(self):
        self.request = RequestFactory().get("/")
        user = AnonymousUser()  # technically, Anonymous users cannot access the admin
        self.request.user = user

        self.form_page = FormPage()

        self.FormPageForm = get_form_for_model(
            FormPage,
            form_class=WagtailAdminPageForm,
            fields=["title", "slug", "to_address", "from_address", "subject"],
        )

        panel = FormSubmissionsPanel().bind_to_model(FormPage)
        self.panel = panel.get_bound_panel(
            instance=self.form_page, form=self.FormPageForm(), request=self.request
        )

    def test_render_without_submissions(self):
        """The panel should not be shown if the number of submission is zero."""
        self.assertFalse(self.panel.is_shown())


class TestFormResponsesPanelWithCustomSubmissionClass(WagtailTestUtils, TestCase):
    def setUp(self):
        self.request = RequestFactory().get("/")
        user = AnonymousUser()  # technically, Anonymous users cannot access the admin
        self.request.user = user

        # Create a form page
        self.form_page = make_form_page_with_custom_submission()

        self.FormPageForm = get_form_for_model(
            FormPageWithCustomSubmission,
            form_class=WagtailAdminPageForm,
            fields=["title", "slug", "to_address", "from_address", "subject"],
        )

        self.test_user = self.create_user(username="user-n1kola", password="123")

        panel = FormSubmissionsPanel().bind_to_model(FormPageWithCustomSubmission)
        self.panel = panel.get_bound_panel(
            instance=self.form_page, form=self.FormPageForm(), request=self.request
        )

    def test_render_with_submissions(self):
        """Show the panel with the count of submission and a link to the list_submissions view."""
        new_form_submission = CustomFormPageSubmission.objects.create(
            user=self.test_user,
            page=self.form_page,
            form_data={
                "your_email": "email@domain.com",
                "your_message": "hi joe",
                "your_choices": {"foo": "", "bar": "", "baz": ""},
            },
        )
        new_form_submission.submit_time = "2017-08-29T12:00:00.000Z"
        new_form_submission.save()

        self.assertTrue(self.panel.is_shown())
        result = self.panel.render_html()

        url = reverse("wagtailforms:list_submissions", args=(self.form_page.id,))
        link = f'<a href="{url}">1</a>'

        self.assertIn(link, result)

    def test_render_without_submissions(self):
        """The panel should not be shown if the number of submission is zero."""
        self.assertFalse(self.panel.is_shown())


class TestFormsIndex(WagtailTestUtils, TestCase):
    fixtures = ["test.json"]

    def setUp(self):
        self.login(username="siteeditor", password="password")
        get_form_types.cache_clear()

    @classmethod
    def setUpTestData(cls):
        cls.form_page = Page.objects.specific().get(url_path="/home/contact-us/")
        # Save a revision so latest_revision_created_at is populated, and thus
        # the form page is always shown first when using the default ordering
        # (latest_revision_created_at descending).
        cls.form_page.save_revision()
        cls.models = [
            FormPage,
            FormPageWithRedirect,
            FormPageWithCustomFormBuilder,
            FormPageWithCustomSubmission,
            FormPageWithCustomSubmissionListView,
            JadeFormPage,
            FormPageDemo,
        ]
        cls.make_form_pages()

    @classmethod
    def make_form_pages(cls):
        """
        This makes 100 form pages and adds them as children to 'contact-us'
        This is used to test pagination on the forms index
        """
        for i in range(100):
            cls.form_page.add_child(
                instance=cls.models[i % len(cls.models)](
                    title="Form " + str(i), slug="form-" + str(i), live=True
                )
            )

    def test_forms_index(self):
        response = self.client.get(reverse("wagtailforms:index"))

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/index.html")

    def test_forms_index_pagination(self):
        # Get page two
        response = self.client.get(reverse("wagtailforms:index"), {"p": 2})

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/index.html")

        # Check that we got the correct page
        self.assertEqual(response.context["page_obj"].number, 2)

    def test_forms_index_pagination_invalid(self):
        # Get page two
        response = self.client.get(reverse("wagtailforms:index"), {"p": "Hello world!"})

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/index.html")

        # Check that it got page one
        self.assertEqual(response.context["page_obj"].number, 1)

    def test_forms_index_pagination_out_of_range(self):
        # Get page that is out of range
        response = self.client.get(reverse("wagtailforms:index"), {"p": 99999})

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/index.html")

        # Check that it got the last page
        self.assertEqual(
            response.context["page_obj"].number, response.context["paginator"].num_pages
        )

    def test_cannot_see_forms_without_permission(self):
        self.login(username="admin_only_user", password="password")
        response = self.client.get(reverse("wagtailforms:index"))
        self.assertRedirects(response, reverse("wagtailadmin_home"))

        # Login with as a user without permission to see forms
        self.login(username="eventeditor", password="password")

        response = self.client.get(reverse("wagtailforms:index"))
        self.assertEqual(response.status_code, 200)

        # Check that the user cannot see the form page
        self.assertNotIn(self.form_page, response.context["form_pages"])
        self.assertEqual(len(response.context["form_pages"]), 0)

    def test_can_see_forms_with_permission(self):
        response = self.client.get(reverse("wagtailforms:index"))
        self.assertEqual(response.status_code, 200)

        # Check that the user can see the form page
        self.assertIn(self.form_page, response.context["form_pages"])
        self.assertEqual(len(response.context["form_pages"]), 20)

    def test_cant_see_forms_after_filter_form_submissions_for_user_hook(self):
        # Hook allows to see forms only to superusers
        def construct_forms_for_user(user, queryset):
            if not user.is_superuser:
                queryset = queryset.none()

            return queryset

        response = self.client.get(reverse("wagtailforms:index"))

        # Check that an user can see the form page
        self.assertIn(self.form_page, response.context["form_pages"])
        self.assertEqual(len(response.context["form_pages"]), 20)

        with self.register_hook(
            "filter_form_submissions_for_user", construct_forms_for_user
        ):
            response = self.client.get(reverse("wagtailforms:index"))

        # Check that an user can't see the form page
        self.assertNotIn(self.form_page, response.context["form_pages"])
        self.assertEqual(len(response.context["form_pages"]), 0)

    def test_search(self):
        response = self.client.get(reverse("wagtailforms:index"), {"q": "Form 10"})

        self.assertNotIn(self.form_page, response.context["form_pages"])
        self.assertCountEqual(
            [page.title for page in response.context["form_pages"]],
            ["Form 10"],
        )

    def test_filter_by_page_type(self):
        content_type_ids = [
            ct.pk
            for ct in ContentType.objects.get_for_models(
                FormPageWithRedirect, FormPageDemo
            ).values()
        ]
        response = self.client.get(
            reverse("wagtailforms:index"),
            {"content_type": content_type_ids},
        )

        soup = self.get_soup(response.content)
        inputs = soup.select('input[name="content_type"]')
        self.assertCountEqual(
            [int(input.attrs.get("value")) for input in inputs],
            [ct.pk for ct in ContentType.objects.get_for_models(*self.models).values()],
        )
        selected_cts = soup.select('input[name="content_type"][checked]')
        self.assertEqual(len(selected_cts), 2)
        self.assertCountEqual(
            [int(input.attrs.get("value")) for input in selected_cts],
            content_type_ids,
        )

        # Check that only pages of the selected types are shown
        self.assertNotIn(self.form_page, response.context["form_pages"])
        self.assertEqual(
            {page.__class__ for page in response.context["form_pages"]},
            {FormPageWithRedirect, FormPageDemo},
        )

    def test_search_and_filter(self):
        response = self.client.get(
            reverse("wagtailforms:index"),
            {
                "q": "Contact",
                "content_type": ContentType.objects.get_for_model(FormPage).pk,
            },
        )

        self.assertIn(self.form_page, response.context["form_pages"])
        # The "Contact us one more time" page from the fixtures is not included
        # because it's a FormPageWithCustomSubmission, not a FormPage
        self.assertCountEqual(
            [page.title for page in response.context["form_pages"]],
            ["Contact us"],
        )


@override_settings(WAGTAIL_I18N_ENABLED=True)
class TestFormsIndexWithLocalisationEnabled(WagtailTestUtils, TestCase):
    fixtures = ["test.json"]

    def setUp(self):
        self.login(username="superuser", password="password")
        self.form_page = Page.objects.get(url_path="/home/contact-us/")
        self.en_locale = Locale.get_default()

        self.fr_locale = Locale.objects.create(language_code="fr")
        self.fr_form_page = self.form_page.copy_for_translation(
            self.fr_locale, copy_parents=True
        )
        self.fr_form_page.save()

        self.forms_index_url = reverse("wagtailforms:index")

    def make_form_pages(self, num=100, parent=None):
        """
        This makes 100 form pages and adds them as children to 'contact-us'
        This is used to test pagination on the forms index
        """
        if parent is None:
            parent = self.form_page

        for i in range(num):
            suffix = f"{i} [{parent.locale.get_display_name()}]"
            parent.add_child(
                instance=FormPage(
                    title=f"Form {suffix}",
                    slug=f"form-{i}-{parent.locale_id}",
                    live=True,
                    locale_id=parent.locale_id,
                )
            )

    def test_forms_index(self):
        response = self.client.get(self.forms_index_url)

        # Check response
        self.assertEqual(response.status_code, 200)

        soup = self.get_soup(response.content)
        inputs = soup.select('input[name="locale"]')
        values = [input.attrs.get("value") for input in inputs]
        self.assertEqual(len(inputs), 3)
        self.assertEqual(values, ["", "en", "fr"])

    def test_forms_index_pagination(self):
        # Create some more form pages to make pagination kick in
        # There are 43 pages in total, 2 in test.json, 1 in setUp, and
        # 40 from the following
        self.make_form_pages(parent=self.form_page, num=20)
        self.make_form_pages(parent=self.fr_form_page, num=20)

        # Get page two
        response = self.client.get(self.forms_index_url, {"p": 2})

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/index.html")

        # Check that we got the correct page
        self.assertEqual(response.context["page_obj"].number, 2)

        # Default unfiltered view should show pages from all locales,
        # so page 3 should exist
        response = self.client.get(self.forms_index_url, {"p": 3})
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.context["page_obj"].number, 3)
        self.assertEqual(len(response.context["page_obj"].object_list), 3)

        response = self.client.get(self.forms_index_url, {"p": 4})
        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/index.html")

        # Check that we got the last page
        self.assertEqual(
            response.context["page_obj"].number,
            response.context["paginator"].num_pages,
        )

        # now check the French pages.
        response = self.client.get(
            self.forms_index_url, {"p": 2, "locale": self.fr_locale.language_code}
        )
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.context["page_obj"].number, 2)

    @override_settings(WAGTAIL_I18N_ENABLED=False)
    def test_switcher_doesnt_show_with_i18n_disabled(self):
        response = self.client.get(self.forms_index_url)
        soup = self.get_soup(response.content)
        inputs = soup.select('input[name="locale"]')
        self.assertEqual(len(inputs), 0)


class TestFormsSubmissionsList(WagtailTestUtils, TestCase):
    def setUp(self):
        # Create a form page
        self.form_page = make_form_page()

        # Add a couple of form submissions
        # (save new_form_submission first, so that we're more likely to reveal bugs where
        # we're relying on the database's internal ordering instead of explicitly ordering
        # by submit_time)

        new_form_submission = FormSubmission.objects.create(
            page=self.form_page,
            form_data={
                "your_email": "new@example.com",
                "your_message": "this is a fairly new message",
                "your_choices": ["foo", "baz"],
            },
        )
        new_form_submission.submit_time = "2014-01-01T12:00:00.000Z"
        new_form_submission.save()

        old_form_submission = FormSubmission.objects.create(
            page=self.form_page,
            form_data={
                "your_email": "old@example.com",
                "your_message": "this is a really old message",
            },
        )
        old_form_submission.submit_time = "2013-01-01T12:00:00.000Z"
        old_form_submission.save()

        # Login
        self.login()

    def test_export_urls_include_filters(self):
        list_url = reverse("wagtailforms:list_submissions", args=(self.form_page.id,))

        # Ensure that the download URLs include the filter parameters
        response = self.client.get(list_url, {"name": "Alice"})
        for format in ("xlsx", "csv"):
            with self.subTest(format=format):
                params = urlencode({"name": "Alice", "export": format})
                expected_url = f"{list_url}?{params}"
                self.assertContains(response, escape(expected_url))

    def make_list_submissions(self):
        """
        This makes 100 submissions to test pagination on the forms submissions page
        """
        for i in range(100):
            submission = FormSubmission(
                page=self.form_page, form_data={"hello": "world"}
            )
            submission.save()

    def test_list_submissions(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,))
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/submissions_index.html")
        self.assertEqual(len(response.context["data_rows"]), 2)

        # check display of list values within form submissions
        self.assertContains(response, "foo, baz")

    def test_list_submissions_after_filter_form_submissions_for_user_hook(self):
        # Hook forbids to delete form submissions for everyone
        def construct_forms_for_user(user, queryset):
            return queryset.none()

        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,))
        )

        # An user can see form submissions without the hook
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/submissions_index.html")
        self.assertEqual(len(response.context["data_rows"]), 2)

        with self.register_hook(
            "filter_form_submissions_for_user", construct_forms_for_user
        ):
            response = self.client.get(
                reverse("wagtailforms:list_submissions", args=(self.form_page.id,))
            )

        # An user can't see form submissions with the hook
        self.assertRedirects(response, "/admin/")

    def test_list_submissions_filtering_date_from(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"date_from": "01/01/2014"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/submissions_index.html")
        self.assertEqual(len(response.context["data_rows"]), 1)

    def test_list_submissions_filtering_date_to(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"date_to": "12/31/2013"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/submissions_index.html")
        self.assertEqual(len(response.context["data_rows"]), 1)

    def test_list_submissions_filtering_range(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"date_from": "12/31/2013", "date_to": "01/02/2014"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/submissions_index.html")
        self.assertEqual(len(response.context["data_rows"]), 1)

    def test_list_submissions_pagination(self):
        self.make_list_submissions()

        list_url = reverse("wagtailforms:list_submissions", args=(self.form_page.id,))
        response = self.client.get(list_url, {"p": 2})

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/submissions_index.html")

        # Check that we got the correct page
        self.assertEqual(response.context["page_obj"].number, 2)

        # The delete form should have a 'next' input that points back to the list page
        # with the same pagination querystring
        soup = self.get_soup(response.content)
        delete_url = reverse(
            "wagtailforms:delete_submissions", args=(self.form_page.id,)
        )
        form = soup.find("form", {"action": delete_url})
        self.assertIsNotNone(form)
        next_input = form.find("input", {"name": "next"})
        self.assertIsNotNone(next_input)
        self.assertEqual(next_input.get("value"), f"{list_url}?p=2")

    def test_list_submissions_pagination_invalid(self):
        self.make_list_submissions()

        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"p": "Hello World!"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/submissions_index.html")

        # Check that we got page one
        self.assertEqual(response.context["page_obj"].number, 1)

    def test_list_submissions_pagination_out_of_range(self):
        self.make_list_submissions()

        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"p": 99999},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/submissions_index.html")

        # Check that we got the last page
        self.assertEqual(
            response.context["page_obj"].number, response.context["paginator"].num_pages
        )

    def test_list_submissions_default_order(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,))
        )
        # check default ordering, most recent responses first
        first_row_values = response.context["data_rows"][0]["fields"]
        self.assertIn("this is a fairly new message", first_row_values)

    def test_list_submissions_url_params_ordering_recent_first(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"order_by": "-submit_time"},
        )
        # check ordering matches '-submit_time' (most recent first)
        first_row_values = response.context["data_rows"][0]["fields"]
        self.assertIn("this is a fairly new message", first_row_values)

    def test_list_submissions_url_params_ordering_oldest_first(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"order_by": "submit_time"},
        )
        # check ordering matches 'submit_time' (oldest first)
        first_row_values = response.context["data_rows"][0]["fields"]
        self.assertIn("this is a really old message", first_row_values)


class TestFormsSubmissionsExport(WagtailTestUtils, TestCase):
    def setUp(self):
        # Create a form page
        self.form_page = make_form_page()

        # Add a couple of form submissions
        old_form_submission = FormSubmission.objects.create(
            page=self.form_page,
            form_data={
                "your_email": "old@example.com",
                "your_message": "this is a really old message",
                "your_choices": ["foo", "baz"],
            },
        )
        if settings.USE_TZ:
            old_form_submission.submit_time = "2013-01-01T12:00:00.000Z"
        else:
            old_form_submission.submit_time = "2013-01-01T12:00:00"
        old_form_submission.save()

        new_form_submission = FormSubmission.objects.create(
            page=self.form_page,
            form_data={
                "your_email": "new@example.com",
                "your_message": "this is a fairly new message",
            },
        )
        if settings.USE_TZ:
            new_form_submission.submit_time = "2014-01-01T12:00:00.000Z"
        else:
            new_form_submission.submit_time = "2014-01-01T12:00:00"
        new_form_submission.save()

        # Login
        self.login()

    def test_list_submissions_csv_export(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"export": "csv"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        data_lines = response.getvalue().decode().split("\n")

        self.assertEqual(
            data_lines[0], "Submission date,Your email,Your message,Your choices\r"
        )
        if settings.USE_TZ:
            self.assertEqual(
                data_lines[1],
                '2013-01-01 12:00:00+00:00,old@example.com,this is a really old message,"foo, baz"\r',
            )
            self.assertEqual(
                data_lines[2],
                "2014-01-01 12:00:00+00:00,new@example.com,this is a fairly new message,\r",
            )
        else:
            self.assertEqual(
                data_lines[1],
                '2013-01-01 12:00:00,old@example.com,this is a really old message,"foo, baz"\r',
            )
            self.assertEqual(
                data_lines[2],
                "2014-01-01 12:00:00,new@example.com,this is a fairly new message,\r",
            )

    def test_list_submissions_xlsx_export(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"export": "xlsx"},
        )

        self.assertEqual(response.status_code, 200)
        workbook_data = response.getvalue()
        worksheet = load_workbook(filename=BytesIO(workbook_data))["Sheet1"]
        cell_array = [[cell.value for cell in row] for row in worksheet.rows]
        self.assertEqual(
            cell_array[0],
            ["Submission date", "Your email", "Your message", "Your choices"],
        )
        self.assertEqual(
            cell_array[1],
            [
                datetime.datetime(2013, 1, 1, 12, 0),
                "old@example.com",
                "this is a really old message",
                "foo, baz",
            ],
        )
        self.assertEqual(
            cell_array[2],
            [
                datetime.datetime(2014, 1, 1, 12, 0),
                "new@example.com",
                "this is a fairly new message",
                None,
            ],
        )
        self.assertEqual(len(cell_array), 3)

    def test_list_submissions_csv_large_export(self):
        for i in range(100):
            new_form_submission = FormSubmission.objects.create(
                page=self.form_page,
                form_data={
                    "your-email": "new@example-%s.com" % i,
                    "your-message": "I like things x %s" % i,
                },
            )
            if settings.USE_TZ:
                new_form_submission.submit_time = "2014-01-01T12:00:00.000Z"
            else:
                new_form_submission.submit_time = "2014-01-01T12:00:00"
            new_form_submission.save()

        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"export": "csv"},
        )

        # Check that csv export is not paginated
        self.assertEqual(response.status_code, 200)
        data_lines = response.getvalue().decode().split("\n")
        self.assertEqual(104, len(data_lines))

    def test_list_submissions_csv_export_after_filter_form_submissions_for_user_hook(
        self,
    ):
        # Hook forbids to delete form submissions for everyone
        def construct_forms_for_user(user, queryset):
            return queryset.none()

        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"export": "csv"},
        )

        # An user can export form submissions without the hook
        self.assertEqual(response.status_code, 200)
        data_lines = response.getvalue().decode().split("\n")

        self.assertEqual(
            data_lines[0], "Submission date,Your email,Your message,Your choices\r"
        )
        if settings.USE_TZ:
            self.assertEqual(
                data_lines[1],
                '2013-01-01 12:00:00+00:00,old@example.com,this is a really old message,"foo, baz"\r',
            )
            self.assertEqual(
                data_lines[2],
                "2014-01-01 12:00:00+00:00,new@example.com,this is a fairly new message,\r",
            )
        else:
            self.assertEqual(
                data_lines[1],
                '2013-01-01 12:00:00,old@example.com,this is a really old message,"foo, baz"\r',
            )
            self.assertEqual(
                data_lines[2],
                "2014-01-01 12:00:00,new@example.com,this is a fairly new message,\r",
            )

        with self.register_hook(
            "filter_form_submissions_for_user", construct_forms_for_user
        ):
            response = self.client.get(
                reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
                {"export": "csv"},
            )

        # An user can't export form submission with the hook
        self.assertRedirects(response, "/admin/")

    def test_list_submissions_csv_export_with_date_from_filtering(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"export": "csv", "date_from": "01/01/2014"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        data_lines = response.getvalue().decode().split("\n")

        self.assertEqual(
            data_lines[0], "Submission date,Your email,Your message,Your choices\r"
        )
        if settings.USE_TZ:
            self.assertEqual(
                data_lines[1],
                "2014-01-01 12:00:00+00:00,new@example.com,this is a fairly new message,\r",
            )
        else:
            self.assertEqual(
                data_lines[1],
                "2014-01-01 12:00:00,new@example.com,this is a fairly new message,\r",
            )

    def test_list_submissions_csv_export_with_date_to_filtering(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"export": "csv", "date_to": "12/31/2013"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        data_lines = response.getvalue().decode().split("\n")

        self.assertEqual(
            data_lines[0], "Submission date,Your email,Your message,Your choices\r"
        )
        if settings.USE_TZ:
            self.assertEqual(
                data_lines[1],
                '2013-01-01 12:00:00+00:00,old@example.com,this is a really old message,"foo, baz"\r',
            )
        else:
            self.assertEqual(
                data_lines[1],
                '2013-01-01 12:00:00,old@example.com,this is a really old message,"foo, baz"\r',
            )

    def test_list_submissions_csv_export_with_range_filtering(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"export": "csv", "date_from": "12/31/2013", "date_to": "01/02/2014"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        data_lines = response.getvalue().decode().split("\n")

        self.assertEqual(
            data_lines[0], "Submission date,Your email,Your message,Your choices\r"
        )
        if settings.USE_TZ:
            self.assertEqual(
                data_lines[1],
                "2014-01-01 12:00:00+00:00,new@example.com,this is a fairly new message,\r",
            )
        else:
            self.assertEqual(
                data_lines[1],
                "2014-01-01 12:00:00,new@example.com,this is a fairly new message,\r",
            )

    def test_list_submissions_csv_export_with_unicode_in_submission(self):
        unicode_form_submission = FormSubmission.objects.create(
            page=self.form_page,
            form_data={
                "your_email": "unicode@example.com",
                "your_message": "こんにちは、世界",
            },
        )
        unicode_form_submission.submit_time = "2014-01-02T12:00:00.000Z"
        unicode_form_submission.save()

        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"date_from": "01/02/2014", "export": "csv"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        data_line = response.getvalue().decode("utf-8").split("\n")[1]
        self.assertIn("こんにちは、世界", data_line)

    def test_list_submissions_csv_export_with_unicode_in_field(self):
        FormField.objects.create(
            page=self.form_page,
            sort_order=2,
            label="Выберите самую любимую IDE для разработке на Python",
            help_text="Вы можете выбрать только один вариант",
            field_type="radio",
            required=True,
            choices="PyCharm,vim,nano",
        )
        unicode_form_submission = FormSubmission.objects.create(
            page=self.form_page,
            form_data={
                "your_email": "unicode@example.com",
                "your_message": "We don't need unicode here",
                "u0412u044bu0431u0435u0440u0438u0442u0435_u0441u0430u043cu0443u044e_u043bu044eu0431u0438u043cu0443u044e_ide_u0434u043bu044f_u0440u0430u0437u0440u0430u0431u043eu0442u043au0435_u043du0430_python": "vim",
            },
        )
        unicode_form_submission.submit_time = "2014-01-02T12:00:00.000Z"
        unicode_form_submission.save()

        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"date_from": "01/02/2014", "export": "csv"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)

        data_lines = response.getvalue().decode("utf-8").split("\n")
        self.assertIn(
            "Выберите самую любимую IDE для разработке на Python", data_lines[0]
        )
        self.assertIn("vim", data_lines[1])


class TestCustomFormsSubmissionsExport(WagtailTestUtils, TestCase):
    def create_test_user_without_admin(self, username):
        return self.create_user(username=username, password="123")

    def setUp(self):
        # Create a form page
        self.form_page = make_form_page_with_custom_submission()

        # Add a couple of form submissions
        old_form_submission = CustomFormPageSubmission.objects.create(
            user=self.create_test_user_without_admin("user-john"),
            page=self.form_page,
            form_data={
                "your_email": "old@example.com",
                "your_message": "this is a really old message",
            },
        )
        if settings.USE_TZ:
            old_form_submission.submit_time = "2013-01-01T12:00:00.000Z"
        else:
            old_form_submission.submit_time = "2013-01-01T12:00:00"
        old_form_submission.save()

        new_form_submission = CustomFormPageSubmission.objects.create(
            user=self.create_test_user_without_admin("user-m1kola"),
            page=self.form_page,
            form_data={
                "your_email": "new@example.com",
                "your_message": "this is a fairly new message",
            },
        )
        if settings.USE_TZ:
            new_form_submission.submit_time = "2014-01-01T12:00:00.000Z"
        else:
            new_form_submission.submit_time = "2014-01-01T12:00:00"
        new_form_submission.save()

        # Login
        self.login()

    def test_list_submissions_csv_export(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"export": "csv"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        data_lines = response.getvalue().decode().split("\n")

        self.assertEqual(
            data_lines[0],
            "User email,Submission date,Your email,Your message,Your choices\r",
        )
        if settings.USE_TZ:
            self.assertEqual(
                data_lines[1],
                "user-john@example.com,2013-01-01 12:00:00+00:00,old@example.com,this is a really old message,\r",
            )
            self.assertEqual(
                data_lines[2],
                "user-m1kola@example.com,2014-01-01 12:00:00+00:00,new@example.com,this is a fairly new message,\r",
            )
        else:
            self.assertEqual(
                data_lines[1],
                "user-john@example.com,2013-01-01 12:00:00,old@example.com,this is a really old message,\r",
            )
            self.assertEqual(
                data_lines[2],
                "user-m1kola@example.com,2014-01-01 12:00:00,new@example.com,this is a fairly new message,\r",
            )

    def test_list_submissions_csv_export_with_date_from_filtering(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"export": "csv", "date_from": "01/01/2014"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        data_lines = response.getvalue().decode().split("\n")

        self.assertEqual(
            data_lines[0],
            "User email,Submission date,Your email,Your message,Your choices\r",
        )
        if settings.USE_TZ:
            self.assertEqual(
                data_lines[1],
                "user-m1kola@example.com,2014-01-01 12:00:00+00:00,new@example.com,this is a fairly new message,\r",
            )
        else:
            self.assertEqual(
                data_lines[1],
                "user-m1kola@example.com,2014-01-01 12:00:00,new@example.com,this is a fairly new message,\r",
            )

    def test_list_submissions_csv_export_with_date_to_filtering(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"export": "csv", "date_to": "12/31/2013"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        data_lines = response.getvalue().decode().split("\n")

        self.assertEqual(
            data_lines[0],
            "User email,Submission date,Your email,Your message,Your choices\r",
        )
        if settings.USE_TZ:
            self.assertEqual(
                data_lines[1],
                "user-john@example.com,2013-01-01 12:00:00+00:00,old@example.com,this is a really old message,\r",
            )
        else:
            self.assertEqual(
                data_lines[1],
                "user-john@example.com,2013-01-01 12:00:00,old@example.com,this is a really old message,\r",
            )

    def test_list_submissions_csv_export_with_range_filtering(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"export": "csv", "date_from": "12/31/2013", "date_to": "01/02/2014"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        data_lines = response.getvalue().decode().split("\n")

        self.assertEqual(
            data_lines[0],
            "User email,Submission date,Your email,Your message,Your choices\r",
        )
        if settings.USE_TZ:
            self.assertEqual(
                data_lines[1],
                "user-m1kola@example.com,2014-01-01 12:00:00+00:00,new@example.com,this is a fairly new message,\r",
            )
        else:
            self.assertEqual(
                data_lines[1],
                "user-m1kola@example.com,2014-01-01 12:00:00,new@example.com,this is a fairly new message,\r",
            )

    def test_list_submissions_csv_export_with_unicode_in_submission(self):
        unicode_form_submission = CustomFormPageSubmission.objects.create(
            user=self.create_test_user_without_admin("user-bob"),
            page=self.form_page,
            form_data={
                "your_email": "unicode@example.com",
                "your_message": "こんにちは、世界",
            },
        )
        unicode_form_submission.submit_time = "2014-01-02T12:00:00.000Z"
        unicode_form_submission.save()

        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"date_from": "01/02/2014", "export": "csv"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        data_line = response.getvalue().decode("utf-8").split("\n")[1]
        self.assertIn("こんにちは、世界", data_line)

    def test_list_submissions_csv_export_with_unicode_in_field(self):
        FormFieldWithCustomSubmission.objects.create(
            page=self.form_page,
            sort_order=2,
            label="Выберите самую любимую IDE для разработке на Python",
            help_text="Вы можете выбрать только один вариант",
            field_type="radio",
            required=True,
            choices="PyCharm,vim,nano",
        )
        unicode_form_submission = CustomFormPageSubmission.objects.create(
            user=self.create_test_user_without_admin("user-bob"),
            page=self.form_page,
            form_data={
                "your-email": "unicode@example.com",
                "your-message": "We don't need unicode here",
                "u0412u044bu0431u0435u0440u0438u0442u0435_u0441u0430u043cu0443u044e_u043bu044eu0431u0438u043cu0443u044e_ide_u0434u043bu044f_u0440u0430u0437u0440u0430u0431u043eu0442u043au0435_u043du0430_python": "vim",
            },
        )
        unicode_form_submission.submit_time = "2014-01-02T12:00:00.000Z"
        unicode_form_submission.save()

        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"date_from": "01/02/2014", "export": "csv"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)

        data_lines = response.getvalue().decode("utf-8").split("\n")
        self.assertIn(
            "Выберите самую любимую IDE для разработке на Python", data_lines[0]
        )
        self.assertIn("vim", data_lines[1])


class TestCustomFormsSubmissionsList(WagtailTestUtils, TestCase):
    def create_test_user_without_admin(self, username):
        return self.create_user(username=username, password="123")

    def setUp(self):
        # Create a form page
        self.form_page = make_form_page_with_custom_submission()

        # Add a couple of form submissions
        old_form_submission = CustomFormPageSubmission.objects.create(
            user=self.create_test_user_without_admin("user-john"),
            page=self.form_page,
            form_data={
                "your_email": "old@example.com",
                "your_message": "this is a really old message",
            },
        )
        old_form_submission.submit_time = "2013-01-01T12:00:00.000Z"
        old_form_submission.save()

        new_form_submission = CustomFormPageSubmission.objects.create(
            user=self.create_test_user_without_admin("user-m1kola"),
            page=self.form_page,
            form_data={
                "your_email": "new@example.com",
                "your_message": "this is a fairly new message",
            },
        )
        new_form_submission.submit_time = "2014-01-01T12:00:00.000Z"
        new_form_submission.save()

        # Login
        self.login()

    def make_list_submissions(self):
        """
        This makes 100 submissions to test pagination on the forms submissions page
        """
        for i in range(100):
            submission = CustomFormPageSubmission(
                user=self.create_test_user_without_admin("generated-username-%s" % i),
                page=self.form_page,
                form_data={
                    "your_email": "generated-your-email-%s" % i,
                    "your_message": "generated-your-message-%s" % i,
                },
            )
            submission.save()

    def test_list_submissions(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,))
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/submissions_index.html")
        self.assertEqual(len(response.context["data_rows"]), 2)

        # CustomFormPageSubmission have custom field. This field should appear in the listing
        self.assertContains(
            response, '<th id="useremail" class="">User email</th>', html=True
        )
        self.assertContains(response, "<td>user-m1kola@example.com</td>", html=True)
        self.assertContains(response, "<td>user-john@example.com</td>", html=True)

    def test_list_submissions_filtering_date_from(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"date_from": "01/01/2014"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/submissions_index.html")
        self.assertEqual(len(response.context["data_rows"]), 1)

        # CustomFormPageSubmission have custom field. This field should appear in the listing
        self.assertContains(
            response, '<th id="useremail" class="">User email</th>', html=True
        )
        self.assertContains(response, "<td>user-m1kola@example.com</td>", html=True)

    def test_list_submissions_filtering_date_to(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"date_to": "12/31/2013"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/submissions_index.html")
        self.assertEqual(len(response.context["data_rows"]), 1)

        # CustomFormPageSubmission have custom field. This field should appear in the listing
        self.assertContains(
            response, '<th id="useremail" class="">User email</th>', html=True
        )
        self.assertContains(response, "<td>user-john@example.com</td>", html=True)

    def test_list_submissions_filtering_range(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"date_from": "12/31/2013", "date_to": "01/02/2014"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/submissions_index.html")
        self.assertEqual(len(response.context["data_rows"]), 1)

        # CustomFormPageSubmission have custom field. This field should appear in the listing
        self.assertContains(
            response, '<th id="useremail" class="">User email</th>', html=True
        )
        self.assertContains(response, "<td>user-m1kola@example.com</td>", html=True)

    def test_list_submissions_pagination(self):
        self.make_list_submissions()

        list_url = reverse("wagtailforms:list_submissions", args=(self.form_page.id,))
        response = self.client.get(list_url, {"p": 2})

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/submissions_index.html")

        # Check that we got the correct page
        self.assertEqual(response.context["page_obj"].number, 2)

        # CustomFormPageSubmission have custom field. This field should appear in the listing
        self.assertContains(
            response, '<th id="useremail" class="">User email</th>', html=True
        )
        self.assertContains(response, "generated-username-", count=20)

        # The delete form should have a 'next' input that points back to the list page
        # with the same pagination querystring
        soup = self.get_soup(response.content)
        delete_url = reverse(
            "wagtailforms:delete_submissions", args=(self.form_page.id,)
        )
        form = soup.find("form", {"action": delete_url})
        self.assertIsNotNone(form)
        next_input = form.find("input", {"name": "next"})
        self.assertIsNotNone(next_input)
        self.assertEqual(next_input.get("value"), f"{list_url}?p=2")

    def test_list_submissions_pagination_invalid(self):
        self.make_list_submissions()

        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"p": "Hello World!"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/submissions_index.html")

        # Check that we got page one
        self.assertEqual(response.context["page_obj"].number, 1)

    def test_list_submissions_pagination_out_of_range(self):
        self.make_list_submissions()

        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"p": 99999},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/submissions_index.html")

        # Check that we got the last page
        self.assertEqual(
            response.context["page_obj"].number, response.context["paginator"].num_pages
        )


class TestDeleteFormSubmission(WagtailTestUtils, TestCase):
    fixtures = ["test.json"]

    def setUp(self):
        self.login(username="siteeditor", password="password")
        self.form_page = Page.objects.get(url_path="/home/contact-us/")

    def test_delete_submission_show_confirmation(self):
        delete_url = reverse(
            "wagtailforms:delete_submissions", args=(self.form_page.id,)
        )
        list_url = reverse("wagtailforms:list_submissions", args=(self.form_page.id,))

        response = self.client.get(
            reverse("wagtailforms:delete_submissions", args=(self.form_page.id,))
            + f"?selected-submissions={FormSubmission.objects.first().id}"
        )
        self.assertEqual(response.status_code, 200)
        # Check show confirm page when HTTP method is GET
        self.assertTemplateUsed(response, "wagtailforms/confirm_delete.html")

        # Check that the deletion has not happened with GET request
        self.assertEqual(FormSubmission.objects.count(), 2)

        # The delete form should have a 'next' input that points back to the list page
        soup = self.get_soup(response.content)
        form = soup.select_one(f'form[action^="{delete_url}"]')
        self.assertIsNotNone(form)
        next_input = form.find("input", {"name": "next"})
        self.assertIsNotNone(next_input)
        self.assertEqual(next_input.get("value"), list_url)

    def test_delete_submission_with_permissions(self):
        response = self.client.post(
            reverse("wagtailforms:delete_submissions", args=(self.form_page.id,))
            + f"?selected-submissions={FormSubmission.objects.first().id}"
        )

        # Check that the submission is gone
        self.assertEqual(FormSubmission.objects.count(), 1)
        # Should be redirected to list of submissions
        self.assertRedirects(
            response,
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
        )

    def test_delete_multiple_submissions_with_permissions(self):
        response = self.client.post(
            reverse("wagtailforms:delete_submissions", args=(self.form_page.id,))
            + "?selected-submissions={}&selected-submissions={}".format(
                FormSubmission.objects.first().id, FormSubmission.objects.last().id
            )
        )

        # Check that both submissions are gone
        self.assertEqual(FormSubmission.objects.count(), 0)
        # Should be redirected to list of submissions
        self.assertRedirects(
            response,
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
        )

    def test_delete_submission_bad_permissions(self):
        self.login(username="eventeditor", password="password")

        response = self.client.post(
            reverse("wagtailforms:delete_submissions", args=(self.form_page.id,))
            + f"?selected-submissions={FormSubmission.objects.first().id}"
        )

        # Check that the user received a permission denied response
        self.assertRedirects(response, "/admin/")

        # Check that the deletion has not happened
        self.assertEqual(FormSubmission.objects.count(), 2)

    def test_delete_submission_after_filter_form_submissions_for_user_hook(self):
        # Hook forbids to delete form submissions for everyone
        def construct_forms_for_user(user, queryset):
            return queryset.none()

        with self.register_hook(
            "filter_form_submissions_for_user", construct_forms_for_user
        ):
            response = self.client.post(
                reverse("wagtailforms:delete_submissions", args=(self.form_page.id,))
                + f"?selected-submissions={FormSubmission.objects.first().id}"
            )

        # An user can't delete a from submission with the hook
        self.assertRedirects(response, "/admin/")
        self.assertEqual(FormSubmission.objects.count(), 2)

        # An user can delete a form submission without the hook
        response = self.client.post(
            reverse("wagtailforms:delete_submissions", args=(self.form_page.id,))
            + "?selected-submissions={}".format(
                CustomFormPageSubmission.objects.first().id
            )
        )
        self.assertEqual(FormSubmission.objects.count(), 1)
        self.assertRedirects(
            response,
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
        )

    def test_delete_submission_with_next_url(self):
        submission_id = FormSubmission.objects.first().id
        delete_url = reverse(
            "wagtailforms:delete_submissions", args=(self.form_page.id,)
        )
        list_url = reverse("wagtailforms:list_submissions", args=(self.form_page.id,))
        next_url = list_url + "?p=2"

        response = self.client.get(
            reverse("wagtailforms:delete_submissions", args=(self.form_page.id,))
            + f"?selected-submissions={submission_id}&next={next_url}"
        )
        self.assertEqual(response.status_code, 200)

        # The delete form should have a 'next' input that points back to the list page
        # with the same pagination querystring
        soup = self.get_soup(response.content)
        form = soup.select_one(f'form[action^="{delete_url}"]')
        self.assertIsNotNone(form)
        next_input = form.find("input", {"name": "next"})
        self.assertIsNotNone(next_input)
        self.assertEqual(next_input.get("value"), next_url)

        # Submitting the form should redirect to the next URL
        response = self.client.post(
            reverse("wagtailforms:delete_submissions", args=(self.form_page.id,)),
            {
                "selected-submissions": submission_id,
                "next": next_url,
            },
        )
        self.assertRedirects(response, next_url)


class TestDeleteCustomFormSubmission(WagtailTestUtils, TestCase):
    fixtures = ["test.json"]

    def setUp(self):
        self.login(username="siteeditor", password="password")
        self.form_page = Page.objects.get(url_path="/home/contact-us-one-more-time/")

    def test_delete_submission_show_confirmation(self):
        response = self.client.get(
            reverse("wagtailforms:delete_submissions", args=(self.form_page.id,))
            + "?selected-submissions={}".format(
                CustomFormPageSubmission.objects.first().id
            )
        )

        # Check show confirm page when HTTP method is GET
        self.assertTemplateUsed(response, "wagtailforms/confirm_delete.html")

        # Check that the deletion has not happened with GET request
        self.assertEqual(CustomFormPageSubmission.objects.count(), 2)

    def test_delete_submission_with_permissions(self):
        response = self.client.post(
            reverse("wagtailforms:delete_submissions", args=(self.form_page.id,))
            + "?selected-submissions={}".format(
                CustomFormPageSubmission.objects.first().id
            )
        )

        # Check that the submission is gone
        self.assertEqual(CustomFormPageSubmission.objects.count(), 1)
        # Should be redirected to list of submissions
        self.assertRedirects(
            response,
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
        )

    def test_delete_multiple_submissions_with_permissions(self):
        response = self.client.post(
            reverse("wagtailforms:delete_submissions", args=(self.form_page.id,))
            + "?selected-submissions={}&selected-submissions={}".format(
                CustomFormPageSubmission.objects.first().id,
                CustomFormPageSubmission.objects.last().id,
            )
        )

        # Check that both submissions are gone
        self.assertEqual(CustomFormPageSubmission.objects.count(), 0)
        # Should be redirected to list of submissions
        self.assertRedirects(
            response,
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
        )

    def test_delete_submission_bad_permissions(self):
        self.login(username="eventeditor", password="password")

        response = self.client.post(
            reverse("wagtailforms:delete_submissions", args=(self.form_page.id,))
            + "?selected-submissions={}".format(
                CustomFormPageSubmission.objects.first().id
            )
        )

        # Check that the user received a permission denied response
        self.assertRedirects(response, "/admin/")

        # Check that the deletion has not happened
        self.assertEqual(CustomFormPageSubmission.objects.count(), 2)


class TestFormsWithCustomSubmissionsList(WagtailTestUtils, TestCase):
    def create_test_user_without_admin(self, username):
        return self.create_user(username=username, password="123")

    def setUp(self):
        # Create a form page

        home_page = Page.objects.get(url_path="/home/")
        self.form_page = home_page.add_child(
            instance=FormPageWithCustomSubmissionListView(
                title="Willy Wonka Chocolate Ideas",
                slug="willy-wonka-chocolate-ideas",
                to_address="willy@wonka.com",
                from_address="info@wonka.com",
                subject="Chocolate Idea Submitted!",
            )
        )
        FormFieldForCustomListViewPage.objects.create(
            page=self.form_page,
            sort_order=1,
            label="Your email",
            field_type="email",
            required=True,
        )
        FormFieldForCustomListViewPage.objects.create(
            page=self.form_page,
            sort_order=2,
            label="Chocolate",
            field_type="singleline",
            required=True,
        )
        FormFieldForCustomListViewPage.objects.create(
            page=self.form_page,
            sort_order=3,
            label="Ingredients",
            field_type="multiline",
            required=True,
        )
        self.choices = [
            "What is chocolate?",
            "Mediocre",
            "Much excitement",
            "Wet my pants excited!",
        ]
        FormFieldForCustomListViewPage.objects.create(
            page=self.form_page,
            sort_order=4,
            label="Your Excitement",
            field_type="radio",
            required=True,
            choices=",".join(self.choices),
        )

        self.test_user_1 = self.create_test_user_without_admin("user-chocolate-maniac")
        self.test_user_2 = self.create_test_user_without_admin("user-chocolate-guy")

        # add a couple of initial form submissions for testing ordering
        new_form_submission = CustomFormPageSubmission.objects.create(
            page=self.form_page,
            user=self.test_user_1,
            form_data={
                "your_email": "new@example.com",
                "chocolate": "White Chocolate",
                "ingredients": "White colouring",
                "your_excitement": self.choices[2],
            },
        )
        if settings.USE_TZ:
            new_form_submission.submit_time = "2017-10-01T12:00:00.000Z"
        else:
            new_form_submission.submit_time = "2017-10-01T12:00:00"
        new_form_submission.save()

        old_form_submission = CustomFormPageSubmission.objects.create(
            page=self.form_page,
            user=self.test_user_2,
            form_data={
                "your_email": "old@example.com",
                "chocolate": "Dark Chocolate",
                "ingredients": "Charcoal",
                "your_excitement": self.choices[0],
            },
        )
        if settings.USE_TZ:
            old_form_submission.submit_time = "2017-01-01T12:00:00.000Z"
        else:
            old_form_submission.submit_time = "2017-01-01T12:00:00"
        old_form_submission.save()

        self.login()

    def make_list_submissions(self):
        """Make 100 submissions to test pagination on the forms submissions page"""
        for i in range(120):
            submission = CustomFormPageSubmission(
                page=self.form_page,
                user=self.test_user_1,
                form_data={
                    "your_email": "foo-%s@bar.com" % i,
                    "chocolate": "Chocolate No.%s" % i,
                    "your_excitement": self.choices[3],
                },
            )
            submission.save()

    def test_list_submissions(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,))
        )

        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/submissions_index.html")
        self.assertEqual(len(response.context["data_rows"]), 2)

        # check display of list values within form submissions
        self.assertContains(response, "Much excitement")
        self.assertContains(response, "White Chocolate")
        self.assertContains(response, "Dark Chocolate")

    def test_list_submissions_pagination(self):
        self.make_list_submissions()

        list_url = reverse("wagtailforms:list_submissions", args=(self.form_page.id,))
        response = self.client.get(list_url, {"p": 2})

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/submissions_index.html")

        # test that paginate by 50 is working, should be 3 max pages (~120 values)
        self.assertContains(response, "Page 2 of 3")
        self.assertContains(response, "Wet my pants excited!", count=50)
        self.assertEqual(response.context["page_obj"].number, 2)

        # The delete form should have a 'next' input that points back to the list page
        # with the same pagination querystring
        soup = self.get_soup(response.content)
        delete_url = reverse(
            "wagtailforms:delete_submissions", args=(self.form_page.id,)
        )
        form = soup.find("form", {"action": delete_url})
        self.assertIsNotNone(form)
        next_input = form.find("input", {"name": "next"})
        self.assertIsNotNone(next_input)
        self.assertEqual(next_input.get("value"), f"{list_url}?p=2")

    def test_list_submissions_csv_export(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,)),
            {"export": "csv"},
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        data_lines = response.getvalue().decode().split("\n")
        self.assertIn(
            'filename="%s-export' % self.form_page.slug,
            response.get("Content-Disposition"),
        )
        self.assertEqual(
            data_lines[0],
            "User email,Submission date,Your email,Chocolate,Ingredients,Your Excitement\r",
        )
        # first result should be the most recent as order_csv has been reversed
        if settings.USE_TZ:
            self.assertEqual(
                data_lines[1],
                "user-chocolate-maniac@example.com,2017-10-01 12:00:00+00:00,new@example.com,White Chocolate,White colouring,Much excitement\r",
            )
            self.assertEqual(
                data_lines[2],
                "user-chocolate-guy@example.com,2017-01-01 12:00:00+00:00,old@example.com,Dark Chocolate,Charcoal,What is chocolate?\r",
            )
        else:
            self.assertEqual(
                data_lines[1],
                "user-chocolate-maniac@example.com,2017-10-01 12:00:00,new@example.com,White Chocolate,White colouring,Much excitement\r",
            )
            self.assertEqual(
                data_lines[2],
                "user-chocolate-guy@example.com,2017-01-01 12:00:00,old@example.com,Dark Chocolate,Charcoal,What is chocolate?\r",
            )

    def test_list_submissions_ordering(self):
        form_submission = CustomFormPageSubmission.objects.create(
            page=self.form_page,
            user=self.create_test_user_without_admin("user-aaa-aaa"),
            form_data={
                "your_email": "new@example.com",
                "chocolate": "Old chocolate idea",
                "ingredients": "Sugar",
                "your_excitement": self.choices[2],
            },
        )
        form_submission.submit_time = "2016-01-01T12:00:00.000Z"
        form_submission.save()

        # check ordering matches default which is overridden to be 'submit_time' (oldest first)
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,))
        )
        first_row_values = response.context["data_rows"][0]["fields"]
        self.assertIn("Old chocolate idea", first_row_values)


class TestFormsWithCustomFormBuilderSubmissionsList(WagtailTestUtils, TestCase):
    def setUp(self):
        home_page = Page.objects.get(url_path="/home/")
        form_page = home_page.add_child(
            instance=FormPageWithCustomFormBuilder(
                title="Support Request",
                slug="support-request",
                to_address="it@jenkins.com",
                from_address="support@jenkins.com",
                subject="Support Request Submitted",
            )
        )
        ExtendedFormField.objects.create(
            page=form_page,
            sort_order=1,
            label="Name",
            field_type="singleline",  # singleline field will be max_length 120
            required=True,
        )
        ExtendedFormField.objects.create(
            page=form_page,
            sort_order=1,
            label="Device IP Address",
            field_type="ipaddress",
            required=True,
        )

        for i in range(20):
            submission = FormSubmission.objects.create(
                page=form_page,
                form_data={
                    "name": "John %s" % i,
                    "device_ip_address": "192.0.2.%s" % i,
                },
            )
            submission.save()
        self.form_page = form_page
        # Login
        self.login()

    def test_list_submissions(self):
        response = self.client.get(
            reverse("wagtailforms:list_submissions", args=(self.form_page.id,))
        )

        # Check response
        self.assertEqual(response.status_code, 200)
        self.assertTemplateUsed(response, "wagtailforms/submissions_index.html")
        self.assertEqual(len(response.context["data_rows"]), 20)

        # check display of list values within form submissions
        self.assertContains(response, "192.0.2.1")
        self.assertContains(response, "192.0.2.15")


class TestDuplicateFormFieldLabels(WagtailTestUtils, TestCase):
    """
    If a user creates two fields with the same label, data cannot be saved correctly.
    See: https://github.com/wagtail/wagtail/issues/585
    """

    fixtures = ["test.json"]

    def setUp(self):
        self.login(username="superuser", password="password")
        # Find root page
        self.root_page = Page.objects.get(id=2)

    def test_adding_duplicate_form_labels(self):
        post_data = {
            "title": "Form page!",
            "content": "Some content",
            "slug": "contact-us",
            "form_fields-TOTAL_FORMS": "3",
            "form_fields-INITIAL_FORMS": "3",
            "form_fields-MIN_NUM_FORMS": "0",
            "form_fields-MAX_NUM_FORMS": "1000",
            "form_fields-0-id": "",
            "form_fields-0-label": "foo",
            "form_fields-0-field_type": "singleline",
            "form_fields-1-id": "",
            "form_fields-1-label": "foo",
            "form_fields-1-field_type": "singleline",
            "form_fields-2-id": "",
            "form_fields-2-label": "bar",
            "form_fields-2-field_type": "singleline",
        }
        response = self.client.post(
            reverse(
                "wagtailadmin_pages:add", args=("tests", "formpage", self.root_page.id)
            ),
            post_data,
        )

        self.assertEqual(response.status_code, 200)

        self.assertContains(
            response,
            text="There is another field with the label foo, please change one of them.",
        )

    def test_adding_duplicate_form_labels_as_cleaned_name(self):
        """
        Ensure form submission fails when attempting to create labels that will resolve
        to the same internal clean_name on the form field.
        """

        post_data = {
            "title": "Form page!",
            "content": "Some content",
            "slug": "contact-us",
            "form_fields-TOTAL_FORMS": "3",
            "form_fields-INITIAL_FORMS": "3",
            "form_fields-MIN_NUM_FORMS": "0",
            "form_fields-MAX_NUM_FORMS": "1000",
            "form_fields-0-id": "",
            "form_fields-0-label": "LOW EARTH ORBIT",
            "form_fields-0-field_type": "singleline",
            "form_fields-1-id": "",
            "form_fields-1-label": "low earth orbit",
            "form_fields-1-field_type": "singleline",
            "form_fields-2-id": "",
            "form_fields-2-label": "bar",
            "form_fields-2-field_type": "singleline",
        }
        response = self.client.post(
            reverse(
                "wagtailadmin_pages:add", args=("tests", "formpage", self.root_page.id)
            ),
            post_data,
        )

        self.assertEqual(response.status_code, 200)

        self.assertContains(
            response,
            text="There is another field with the label LOW EARTH ORBIT, please change one of them.",
        )

    def test_adding_duplicate_form_labels_using_override_clean_name(self):
        """
        Ensure form submission fails when attempting to create labels that will resolve
        to the same clean_name that already exists when using a custom `get_field_clean_name` method
        """

        post_data = {
            "title": "Form page!",
            "content": "Some content",
            "slug": "contact-us",
            "form_fields-TOTAL_FORMS": "3",
            "form_fields-INITIAL_FORMS": "3",
            "form_fields-MIN_NUM_FORMS": "0",
            "form_fields-MAX_NUM_FORMS": "1000",
            "form_fields-0-id": "",
            "form_fields-0-label": "duplicate 1",
            "form_fields-0-field_type": "singleline",
            "form_fields-1-id": "",
            "form_fields-1-label": "duplicate 2",
            "form_fields-1-field_type": "singleline",
            "form_fields-2-id": "",
            "form_fields-2-label": "bar",
            "form_fields-2-field_type": "singleline",
        }
        response = self.client.post(
            reverse(
                "wagtailadmin_pages:add",
                args=("tests", "formpagewithcustomformbuilder", self.root_page.id),
            ),
            post_data,
        )

        self.assertEqual(response.status_code, 200)

        self.assertContains(
            response,
            text="There is another field with the label duplicate 1, please change one of them.",
        )

    def test_rename_existing_field_and_add_new_field_with_clashing_clean_name(
        self,
    ):
        """Ensure duplicate field names are checked against existing field clean_names."""

        form_page = FormPage(
            title="Form page!",
            form_fields=[FormField(label="Test field", field_type="singleline")],
        )
        self.root_page.add_child(instance=form_page)

        # Rename existing field and add new field with label matching original field
        post_data = nested_form_data(
            {
                "title": "Form page!",
                "slug": "form-page",
                "form_fields": inline_formset(
                    [
                        {
                            "id": form_page.form_fields.first().pk,
                            "label": "Other field",
                            "field_type": "singleline",
                        },
                        {"id": "", "label": "Test field", "field_type": "singleline"},
                    ],
                    initial=1,
                ),
                "action-publish": "action-publish",
            }
        )
        response = self.client.post(
            reverse("wagtailadmin_pages:edit", args=[form_page.pk]), post_data
        )

        self.assertEqual(response.status_code, 200)
        self.assertContains(
            response,
            text="There is another field with the label Test field, please change one of them.",
        )


class TestPreview(WagtailTestUtils, TestCase):
    post_data = {
        "title": "Form page!",
        "content": "Some content",
        "slug": "contact-us",
        "form_fields-TOTAL_FORMS": "1",
        "form_fields-INITIAL_FORMS": "1",
        "form_fields-MIN_NUM_FORMS": "0",
        "form_fields-MAX_NUM_FORMS": "1000",
        "form_fields-0-id": "",
        "form_fields-0-label": "Field One",
        "form_fields-0-field_type": "singleline",
    }

    def setUp(self):
        self.login()

        self.homepage = Page.objects.get(id=2)

    def test_form_is_rendered(self):
        preview_url = reverse(
            "wagtailadmin_pages:preview_on_add",
            args=("tests", "formpage", self.homepage.pk),
        )

        response = self.client.post(preview_url, self.post_data)
        self.assertEqual(response.status_code, 200)
        self.assertJSONEqual(
            response.content.decode(),
            {"is_valid": True, "is_available": True},
        )

        response = self.client.get(preview_url)

        self.assertContains(response, '<form action="/contact-us/" method="post">')
        self.assertContains(response, '<label for="id_field_one">Field One</label>')
        self.assertContains(
            response,
            '<input type="text" name="field_one" maxlength="255" id="id_field_one">',
        )

    def test_preview_modes(self):
        preview_url = reverse(
            "wagtailadmin_pages:preview_on_add",
            args=("tests", "formpage", self.homepage.pk),
        )

        response = self.client.post(preview_url, data=self.post_data)
        self.assertEqual(response.status_code, 200)
        self.assertJSONEqual(
            response.content.decode(),
            {"is_valid": True, "is_available": True},
        )

        cases = [
            ("", "tests/form_page.html"),
            ("?mode=form", "tests/form_page.html"),
            ("?mode=landing", "tests/form_page_landing.html"),
        ]

        for params, template in cases:
            with self.subTest(params=params, template=template):
                response = self.client.get(preview_url + params)
                self.assertEqual(response.status_code, 200)
                self.assertTemplateUsed(response, template)


class TestFormPageCreate(WagtailTestUtils, TestCase):
    def setUp(self):
        # Find root page
        self.root_page = Page.objects.get(id=2)

        # Login
        self.user = self.login()

    def test_get_creation_form(self):
        response = self.client.get(
            reverse(
                "wagtailadmin_pages:add",
                args=("tests", "formpage", self.root_page.id),
            )
        )
        self.assertEqual(response.status_code, 200)

    def test_post_creation_form(self):
        post_data = {
            "title": "Form page!",
            "slug": "contact-us",
            "form_fields-TOTAL_FORMS": "1",
            "form_fields-INITIAL_FORMS": "1",
            "form_fields-MIN_NUM_FORMS": "0",
            "form_fields-MAX_NUM_FORMS": "1000",
            "form_fields-0-id": "",
            "form_fields-0-label": "Field One",
            "form_fields-0-field_type": "singleline",
        }
        response = self.client.post(
            reverse(
                "wagtailadmin_pages:add",
                args=("tests", "formpage", self.root_page.id),
            ),
            post_data,
        )
        # Find the page and check it
        page = Page.objects.get(slug="contact-us")

        # Should be redirected to edit page
        self.assertRedirects(
            response, reverse("wagtailadmin_pages:edit", args=(page.id,))
        )


class TestFormPageEdit(WagtailTestUtils, TestCase):
    def setUp(self):
        self.form_page = make_form_page()

        # Login
        self.user = self.login()

    def test_get_edit_form(self):
        response = self.client.get(
            reverse("wagtailadmin_pages:edit", args=(self.form_page.id,))
        )
        self.assertEqual(response.status_code, 200)

    def test_post_edit_form(self):
        post_data = {
            "title": "Updated form page",
            "slug": "contact-us",
            "form_fields-TOTAL_FORMS": "1",
            "form_fields-INITIAL_FORMS": "1",
            "form_fields-MIN_NUM_FORMS": "0",
            "form_fields-MAX_NUM_FORMS": "1000",
            "form_fields-0-id": "",
            "form_fields-0-label": "Field One",
            "form_fields-0-field_type": "singleline",
        }
        response = self.client.post(
            reverse("wagtailadmin_pages:edit", args=(self.form_page.id,)),
            post_data,
        )
        # Should be redirected to edit page
        self.assertRedirects(
            response, reverse("wagtailadmin_pages:edit", args=(self.form_page.id,))
        )
        page = Page.objects.get(slug="contact-us").get_latest_revision_as_object()
        self.assertEqual(page.title, "Updated form page")
