import datetime

from django.test import TestCase
from django.urls import reverse
from django.utils import timezone
from .models import Grouped_order


def create_grouped_order(days_before_delivery_date,days_before_deadline,name):
    """
    Create a question with the given `question_text` and published the
    given number of `days` offset to now (negative for questions published
    in the past, positive for questions that have yet to be published).
    """
    date = timezone.now().date() + datetime.timedelta(days=days_before_delivery_date)
    deadline = timezone.now() + datetime.timedelta(days=days_before_deadline)
    return Grouped_order.objects.create(name=name, orga="test orga",delivery_date=date,deadline=deadline)


class GroupedOrderModelTests(TestCase):

    def test_is_ongoing_with_ongoing_grouped_order(self):
        """
        is_ongoing() returns True if the deadline is not crossed
        """
        deadline = timezone.now() + datetime.timedelta(days=10)
        ongoing_gr_order = Grouped_order(deadline=deadline)
        self.assertIs(ongoing_gr_order.is_ongoing(), True)

    def test_is_ongoing_with_old_grouped_order(self):
        """
        is_ongoing() returns False if the deadline is crossed
        """
        deadline = timezone.now() - datetime.timedelta(hours=1)
        ongoing_gr_order = Grouped_order(deadline=deadline)
        self.assertIs(ongoing_gr_order.is_ongoing(), False)

class GroupedOrderIndexViewTests(TestCase):
    
    def test_no_grouped_orders(self):
        """
        If no grouped order exist, an appropriate message is displayed
        """
        response = self.client.get(reverse('order:index'))
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "Pas de commande groupée pour l'instant")
        self.assertQuerysetEqual(response.context['grouped_order_list']['old_grouped_orders'], [])
        self.assertQuerysetEqual(response.context['grouped_order_list']['orders_over_grouped_orders'], [])
        self.assertQuerysetEqual(response.context['grouped_order_list']['incoming_grouped_orders'], [])

    def test_grouped_orders_in_right_section(self):
        """
        According to their delivery date and deadline, grouped orders are placed in correct section
        """
        future_grouped_order = create_grouped_order(days_before_delivery_date=5,days_before_deadline=2,name="future")
        crossed_deadline_gr_order = create_grouped_order(days_before_delivery_date=2, days_before_deadline=-1,name="crossed deadline")
        passed_deadline_gr_order = create_grouped_order(days_before_delivery_date=-1, days_before_deadline=-3,name="passée")
        response = self.client.get(reverse('order:index'))
        self.assertEqual(response.status_code, 200)
        self.assertNotContains(response, "Pas de commande groupée pour l'instant")
        self.assertContains(response, "Commandes groupées à venir")
        self.assertContains(response, "Livraison à venir")
        self.assertContains(response, "Livraison passée")
        self.assertIs(len(response.context['grouped_order_list']['old_grouped_orders']), 1)
        self.assertIs(len(response.context['grouped_order_list']['orders_over_grouped_orders']), 1)
        self.assertIs(len(response.context['grouped_order_list']['incoming_grouped_orders']), 1)

    def test_grouped_orders_in_right_section__with_only_passed(self):
        """
        According to their delivery date and deadline, grouped orders are placed in correct section
        """
        passed_deadline_gr_order = create_grouped_order(days_before_delivery_date=-1, days_before_deadline=-3,name="passée")
        response = self.client.get(reverse('order:index'))
        self.assertEqual(response.status_code, 200)
        self.assertNotContains(response, "Pas de commande groupée pour l'instant")
        self.assertNotContains(response, "Commandes groupées à venir")
        self.assertNotContains(response, "Livraison à venir")
        self.assertContains(response, "Livraison passée")
        self.assertIs(len(response.context['grouped_order_list']['old_grouped_orders']), 1)

    def test_grouped_orders_in_right_section__with_only_future(self):
        """
        According to their delivery date and deadline, grouped orders are placed in correct section
        """
        future_grouped_order = create_grouped_order(days_before_delivery_date=5,days_before_deadline=2,name="future")
        response = self.client.get(reverse('order:index'))
        self.assertEqual(response.status_code, 200)
        self.assertNotContains(response, "Pas de commande groupée pour l'instant")
        self.assertNotContains(response, "Commandes groupées à venir")
        self.assertContains(response, "Livraison à venir")
        self.assertNotContains(response, "Livraison passée")
        self.assertIs(len(response.context['grouped_order_list']['incoming_grouped_orders']), 1)