"""
Author: Michel Peltriaux
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
Contact: ksp-servicestelle@sgdnord.rlp.de
Created on: 29.08.23

"""
from django.test import RequestFactory
from django.utils.timezone import now
from django.utils.translation import gettext_lazy as _

from compensation.forms.modals.deadline import NewDeadlineModalForm, EditDeadlineModalForm
from konova.models import DeadlineType
from konova.tests.test_views import BaseTestCase
from konova.utils.generators import generate_random_string
from konova.utils.message_templates import DEADLINE_ADDED, DEADLINE_EDITED
from user.models import UserAction


class NewDeadlineModalFormTestCase(BaseTestCase):
    def setUp(self) -> None:
        super().setUp()
        self.request = RequestFactory().request()
        self.request.user = self.superuser
        self.today = now().date()

    def test_init(self):
        form = NewDeadlineModalForm(request=self.request, instance=self.compensation)
        self.assertEqual(form.form_title, str(_("New deadline")))
        self.assertEqual(form.form_caption, str(_("Insert data for the new deadline")))
        self.assertEqual(form.user, self.superuser)
        self.assertEqual(form.request, self.request)

    def test_is_valid(self):
        data = {
            "type": DeadlineType.MAINTAIN,
            "date": self.today,
            "comment": "",
        }
        form = NewDeadlineModalForm(
            data,
            request=self.request,
            instance=self.compensation
        )
        self.assertTrue(form.is_valid())

        data["type"] = DeadlineType.OTHER
        form = NewDeadlineModalForm(
            data,
            request=self.request,
            instance=self.compensation
        )
        self.assertFalse(form.is_valid(), msg=form.errors)
        self.assertTrue(form.has_error("comment"))
        _error = form.errors["comment"]
        self.assertEqual(len(_error), 1)
        self.assertEqual(_error[0], str(_("Please explain this 'other' type of deadline.")))

        data["comment"] = "Test"
        data["type"] = DeadlineType.OTHER
        form = NewDeadlineModalForm(
            data,
            request=self.request,
            instance=self.compensation
        )
        self.assertTrue(form.is_valid())

    def test_save(self):
        data = {
            "type": DeadlineType.MAINTAIN,
            "date": self.today,
            "comment": generate_random_string(length=20, use_letters_lc=True),
        }
        form = NewDeadlineModalForm(
            data,
            request=self.request,
            instance=self.compensation
        )
        self.assertTrue(form.is_valid(), msg=form.errors)
        deadline = form.save()
        self.assertEqual(deadline.type, data["type"])
        self.assertEqual(deadline.date, data["date"])
        self.assertEqual(deadline.comment, data["comment"])
        self.assertIn(deadline, self.compensation.deadlines.all())

        last_log = self.compensation.log.first()
        self.assertEqual(last_log.user, self.superuser)
        self.assertEqual(last_log.action, UserAction.EDITED)
        self.assertEqual(last_log.comment, DEADLINE_ADDED)


class EditDeadlineModalFormTestCase(NewDeadlineModalFormTestCase):
    def setUp(self) -> None:
        super().setUp()

    def test_save(self):
        data = {
            "type": DeadlineType.MAINTAIN,
            "date": self.today,
            "comment": generate_random_string(length=20, use_letters_lc=True),
        }
        form = EditDeadlineModalForm(
            data,
            request=self.request,
            instance=self.compensation,
            deadline=self.finished_deadline,
        )

        self.assertTrue(form.is_valid(), msg=form.errors)
        deadline = form.save()
        self.assertEqual(deadline.type, data["type"])
        self.assertEqual(deadline.date, data["date"])
        self.assertEqual(deadline.comment, data["comment"])

        last_log = self.compensation.log.first()
        self.assertEqual(last_log.action, UserAction.EDITED)
        self.assertEqual(last_log.user, self.superuser)
        self.assertEqual(last_log.comment, DEADLINE_EDITED)
