import datetime

import pytest
<<<<<<< HEAD
from django.urls import reverse
from django.utils import timezone

from la_chariotte.order.models import GroupedOrder, Item, Order

pytestmark = pytest.mark.django_db


def create_grouped_order(days_before_delivery_date, days_before_deadline, name):
=======

from django.urls import reverse
from django.utils import timezone
from la_chariotte.order.models import Grouped_order

pytestmark = pytest.mark.django_db

<<<<<<< HEAD
def create_grouped_order(days_before_delivery_date,days_before_deadline,name):
>>>>>>> 9cc7783 (install pytest)
=======

def create_grouped_order(days_before_delivery_date, days_before_deadline, name):
>>>>>>> f6ec481 (install black and format files)
    """
    Creates a grouped order.
    """
    date = timezone.now().date() + datetime.timedelta(days=days_before_delivery_date)
    deadline = timezone.now() + datetime.timedelta(days=days_before_deadline)
<<<<<<< HEAD
<<<<<<< HEAD
    return GroupedOrder.objects.create(
        name=name, orga="test orga", delivery_date=date, deadline=deadline
    )


class TestGroupedOrderIndexView:
    def test_no_grouped_orders(self, client):
        """
        If no grouped order exist, an appropriate message is displayed
        """
        response = client.get(reverse("order:index"))
        assert response.status_code == 200
        assert "Pas de commande groupée pour l'instant" in response.content.decode()
        assert len(response.context["grouped_order_list"]["old_grouped_orders"]) == 0
        assert (
            len(
                response.context["grouped_order_list"][
                    "crossed_deadline_grouped_orders"
                ]
            )
            == 0
        )
        assert (
            len(response.context["grouped_order_list"]["incoming_grouped_orders"]) == 0
        )

    def test_grouped_orders_in_right_section(self, client):
        """
        According to their delivery date and deadline, grouped orders are placed in the correct section : several gr orders
        """
        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",
        )
        old_gr_order = create_grouped_order(
            days_before_delivery_date=-1, days_before_deadline=-3, name="old"
        )
        response = client.get(reverse("order:index"))
=======
    return Grouped_order.objects.create(name=name, orga="test orga",delivery_date=date,deadline=deadline)
=======
    return Grouped_order.objects.create(
        name=name, orga="test orga", delivery_date=date, deadline=deadline
    )

>>>>>>> f6ec481 (install black and format files)

class TestGroupedOrderIndexView:
    def test_no_grouped_orders(self, client):
        """
        If no grouped order exist, an appropriate message is displayed
        """
        response = client.get(reverse("order:index"))
        assert response.status_code == 200
        assert "Pas de commande groupée pour l'instant" in response.content.decode()
        assert len(response.context["grouped_order_list"]["old_grouped_orders"]) == 0
        assert (
            len(response.context["grouped_order_list"]["orders_over_grouped_orders"])
            == 0
        )
        assert (
            len(response.context["grouped_order_list"]["incoming_grouped_orders"]) == 0
        )

    def test_grouped_orders_in_right_section(self, client):
        """
        According to their delivery date and deadline, grouped orders are placed in the correct section : several gr orders
        """
<<<<<<< HEAD
        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")
        old_gr_order = create_grouped_order(days_before_delivery_date=-1, days_before_deadline=-3,name="old")
        response = client.get(reverse('order:index'))
>>>>>>> 9cc7783 (install pytest)
=======
        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",
        )
        old_gr_order = create_grouped_order(
            days_before_delivery_date=-1, days_before_deadline=-3, name="old"
        )
        response = client.get(reverse("order:index"))
>>>>>>> f6ec481 (install black and format files)
        assert response.status_code == 200
        assert "Pas de commande groupée pour l'instant" not in response.content.decode()
        assert "Commandes groupées à venir" in response.content.decode()
        assert "Livraison à venir" in response.content.decode()
        assert "Livraison passée" in response.content.decode()
<<<<<<< HEAD
<<<<<<< HEAD
        assert len(response.context["grouped_order_list"]["old_grouped_orders"]) == 1
        assert (
            len(
                response.context["grouped_order_list"][
                    "crossed_deadline_grouped_orders"
                ]
            )
=======
        assert len(response.context["grouped_order_list"]["old_grouped_orders"]) == 1
        assert (
            len(response.context["grouped_order_list"]["orders_over_grouped_orders"])
>>>>>>> f6ec481 (install black and format files)
            == 1
        )
        assert (
            len(response.context["grouped_order_list"]["incoming_grouped_orders"]) == 1
        )
        assert (
            response.context["grouped_order_list"]["old_grouped_orders"][0]
            == old_gr_order
        )
        assert (
<<<<<<< HEAD
            response.context["grouped_order_list"]["crossed_deadline_grouped_orders"][0]
=======
            response.context["grouped_order_list"]["orders_over_grouped_orders"][0]
>>>>>>> f6ec481 (install black and format files)
            == crossed_deadline_gr_order
        )
        assert (
            response.context["grouped_order_list"]["incoming_grouped_orders"][0]
            == future_grouped_order
        )
<<<<<<< HEAD

    def test_grouped_orders_in_right_section__with_only_old(self, client):
        """
        According to their delivery date and deadline, grouped orders are placed in correct section : only old gr order
        """
        old_gr_order = create_grouped_order(
            days_before_delivery_date=-1, days_before_deadline=-3, name="passée"
        )
        response = client.get(reverse("order:index"))
=======
        assert len(response.context['grouped_order_list']['old_grouped_orders']) == 1
        assert len(response.context['grouped_order_list']['orders_over_grouped_orders']) == 1
        assert len(response.context['grouped_order_list']['incoming_grouped_orders']) == 1
        assert response.context['grouped_order_list']['old_grouped_orders'][0] == old_gr_order
        assert response.context['grouped_order_list']['orders_over_grouped_orders'][0] == crossed_deadline_gr_order
        assert response.context['grouped_order_list']['incoming_grouped_orders'][0] == future_grouped_order
=======
>>>>>>> f6ec481 (install black and format files)

    def test_grouped_orders_in_right_section__with_only_old(self, client):
        """
        According to their delivery date and deadline, grouped orders are placed in correct section : only old gr order
        """
<<<<<<< HEAD
        old_gr_order = create_grouped_order(days_before_delivery_date=-1, days_before_deadline=-3,name="passée")
        response = client.get(reverse('order:index'))
>>>>>>> 9cc7783 (install pytest)
=======
        old_gr_order = create_grouped_order(
            days_before_delivery_date=-1, days_before_deadline=-3, name="passée"
        )
        response = client.get(reverse("order:index"))
>>>>>>> f6ec481 (install black and format files)
        assert response.status_code == 200
        assert "Pas de commande groupée pour l'instant" not in response.content.decode()
        assert "Commandes groupées à venir" not in response.content.decode()
        assert "Livraison à venir" not in response.content.decode()
        assert "Livraison passée" in response.content.decode()
<<<<<<< HEAD
<<<<<<< HEAD
        assert len(response.context["grouped_order_list"]["old_grouped_orders"]) == 1
        assert (
            len(
                response.context["grouped_order_list"][
                    "crossed_deadline_grouped_orders"
                ]
            )
=======
        assert len(response.context["grouped_order_list"]["old_grouped_orders"]) == 1
        assert (
            len(response.context["grouped_order_list"]["orders_over_grouped_orders"])
>>>>>>> f6ec481 (install black and format files)
            == 0
        )
        assert (
            len(response.context["grouped_order_list"]["incoming_grouped_orders"]) == 0
        )
        assert (
            response.context["grouped_order_list"]["old_grouped_orders"][0]
            == old_gr_order
        )
<<<<<<< HEAD

    def test_grouped_orders_in_right_section__with_only_future(self, client):
        """
        According to their delivery date and deadline, grouped orders are placed in correct section : only incoming gr order
        """
        future_grouped_order = create_grouped_order(
            days_before_delivery_date=5, days_before_deadline=2, name="future"
        )
        response = client.get(reverse("order:index"))
=======
        assert len(response.context['grouped_order_list']['old_grouped_orders']) == 1
        assert len(response.context['grouped_order_list']['orders_over_grouped_orders']) == 0
        assert len(response.context['grouped_order_list']['incoming_grouped_orders']) == 0
        assert response.context['grouped_order_list']['old_grouped_orders'][0] == old_gr_order
=======
>>>>>>> f6ec481 (install black and format files)

    def test_grouped_orders_in_right_section__with_only_future(self, client):
        """
        According to their delivery date and deadline, grouped orders are placed in correct section : only incoming gr order
        """
<<<<<<< HEAD
        future_grouped_order = create_grouped_order(days_before_delivery_date=5,days_before_deadline=2,name="future")
        response = client.get(reverse('order:index'))
>>>>>>> 9cc7783 (install pytest)
=======
        future_grouped_order = create_grouped_order(
            days_before_delivery_date=5, days_before_deadline=2, name="future"
        )
        response = client.get(reverse("order:index"))
>>>>>>> f6ec481 (install black and format files)
        assert response.status_code == 200
        assert "Pas de commande groupée pour l'instant" not in response.content.decode()
        assert "Commandes groupées à venir" in response.content.decode()
        assert "Livraison à venir" not in response.content.decode()
        assert "Livraison passée" not in response.content.decode()
<<<<<<< HEAD
<<<<<<< HEAD
        assert len(response.context["grouped_order_list"]["old_grouped_orders"]) == 0
        assert (
            len(
                response.context["grouped_order_list"][
                    "crossed_deadline_grouped_orders"
                ]
            )
=======
        assert len(response.context["grouped_order_list"]["old_grouped_orders"]) == 0
        assert (
            len(response.context["grouped_order_list"]["orders_over_grouped_orders"])
>>>>>>> f6ec481 (install black and format files)
            == 0
        )
        assert (
            len(response.context["grouped_order_list"]["incoming_grouped_orders"]) == 1
        )
        assert (
            response.context["grouped_order_list"]["incoming_grouped_orders"][0]
            == future_grouped_order
        )
<<<<<<< HEAD


class TestGroupedOrderDetailView:
    def test_order_item(self, client):
        """
        From the OrderDetailView, we order an item using the order form, and it creates an Order woth and Ordered_item inside
        """
        grouped_order = create_grouped_order(
            days_before_delivery_date=5, days_before_deadline=2, name="gr order test"
        )
        item = Item.objects.create(name="test item", grouped_order=grouped_order)
        detail_url = reverse(
            "order:grouped_order_detail",
            kwargs={
                "pk": grouped_order.pk,
            },
        )
        response = client.get(detail_url)
        assert response.status_code == 200
        assert "test item" in response.content.decode()
        assert "gr order test" in response.content.decode()
        assert item.ordered_nb == 0
        order_url = reverse(
            "order:order",
            kwargs={
                "grouped_order_id": grouped_order.pk,
            },
        )
        response = client.post(
            order_url,
            {
                "item": item.pk,
            },
        )
        assert response.status_code == 302
        assert response.url == reverse(
            "order:grouped_order_orga",
            kwargs={
                "pk": grouped_order.pk,
            },
        )
        item.refresh_from_db()
        assert item.ordered_nb == 1
        order = Order.objects.first()
        assert order.ordered_items.count() == 1
=======
        assert len(response.context['grouped_order_list']['old_grouped_orders']) == 0
        assert len(response.context['grouped_order_list']['orders_over_grouped_orders']) == 0
        assert len(response.context['grouped_order_list']['incoming_grouped_orders']) == 1
        assert response.context['grouped_order_list']['incoming_grouped_orders'][0] == future_grouped_order
>>>>>>> 9cc7783 (install pytest)
=======
>>>>>>> f6ec481 (install black and format files)