import datetime

import pytest
from django.contrib import auth
from django.urls import reverse
from django.utils import timezone

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

pytestmark = pytest.mark.django_db


def create_grouped_order(
    days_before_delivery_date, days_before_deadline, name, orga_user
):
    """
    Creates a grouped order.
    """
    date = timezone.now().date() + datetime.timedelta(days=days_before_delivery_date)
    deadline = timezone.now() + datetime.timedelta(days=days_before_deadline)
    return GroupedOrder.objects.create(
        name=name, orga=orga_user, delivery_date=date, deadline=deadline
    )


class TestGroupedOrderIndexView:
    def test_anonymous_user_redirection(self, client):
        """
        If the user is anonymous, they are redirected to login view
        """
        assert auth.get_user(client).is_anonymous
        response = client.get(reverse("order:index"))
        assert response.status_code == 302
        assert response.url.startswith(reverse("accounts:login"))
        assert response.url.endswith(reverse("order:index"))

    def test_no_grouped_orders(self, client_log):
        """
        If no grouped order exist, an appropriate message is displayed
        """
        response = client_log.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_log):
        """
        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",
            orga_user=auth.get_user(client_log),
        )
        crossed_deadline_gr_order = create_grouped_order(
            days_before_delivery_date=2,
            days_before_deadline=-1,
            name="crossed deadline",
            orga_user=auth.get_user(client_log),
        )
        old_gr_order = create_grouped_order(
            days_before_delivery_date=-1,
            days_before_deadline=-3,
            name="old",
            orga_user=auth.get_user(client_log),
        )
        response = client_log.get(reverse("order:index"))
        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 "Anciennes commandes" in response.content.decode()
        assert len(response.context["grouped_order_list"]["old_grouped_orders"]) == 1
        assert (
            len(
                response.context["grouped_order_list"][
                    "crossed_deadline_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"]["crossed_deadline_grouped_orders"][0]
            == crossed_deadline_gr_order
        )
        assert (
            response.context["grouped_order_list"]["incoming_grouped_orders"][0]
            == future_grouped_order
        )

    def test_grouped_orders_in_right_section__with_only_old(self, client_log):
        """
        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",
            orga_user=auth.get_user(client_log),
        )
        response = client_log.get(reverse("order:index"))
        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 "Anciennes commandes" in response.content.decode()
        assert len(response.context["grouped_order_list"]["old_grouped_orders"]) == 1
        assert (
            len(
                response.context["grouped_order_list"][
                    "crossed_deadline_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
        )

    def test_grouped_orders_in_right_section__with_only_future(self, client_log):
        """
        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",
            orga_user=auth.get_user(client_log),
        )
        response = client_log.get(reverse("order:index"))
        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 "Anciennes commandes" not 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"]) == 1
        )
        assert (
            response.context["grouped_order_list"]["incoming_grouped_orders"][0]
            == future_grouped_order
        )

    def test_gr_order_not_organized_by_logged_user(self, client_log, other_user):
        """
        If the logged user is not the organizer of a grouped order they don't see it on IndexView
        """
        logged_user = auth.get_user(client_log)
        future_grouped_order = create_grouped_order(
            days_before_delivery_date=5,
            days_before_deadline=2,
            name="future",
            orga_user=other_user,
        )
        assert future_grouped_order.orga is not logged_user
        response = client_log.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
        )


class TestGroupedOrderDetailView:
    def test_order_item(self, client, other_user):
        """
        From the OrderDetailView, we order an item using the order form, and it creates an Order with an Ordered_item inside
        """
        grouped_order = create_grouped_order(
            days_before_delivery_date=5,
            days_before_deadline=2,
            name="gr order test",
            orga_user=other_user,
        )
        item = Item.objects.create(
            name="test item 1", grouped_order=grouped_order, price=1
        )
        item2 = Item.objects.create(
            name="test item 2", grouped_order=grouped_order, price=5
        )
        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
        assert item2.ordered_nb == 0
        order_url = reverse(
            "order:order",
            kwargs={
                "grouped_order_id": grouped_order.pk,
            },
        )
        response = client.post(
            order_url,
            {
                f"quantity_{item.pk}": 4,
                f"quantity_{item2.pk}": 1,
                "first_name": "Prénom",
                "last_name": "Nom",
                "phone": "0645632569",
                "email": "test@mail.fr",
            },
        )
        assert response.status_code == 302
        order = Order.objects.get(grouped_order=grouped_order.pk)
        assert response.url == reverse(
            "order:order_confirm",
            kwargs={
                "grouped_order_id": grouped_order.pk,
                "pk": order.pk,
            },
        )
        item.refresh_from_db()
        item2.refresh_from_db()
        assert OrderAuthor.objects.first().first_name == "Prénom"
        assert OrderAuthor.objects.first().email == "test@mail.fr"
        assert OrderAuthor.objects.first().phone == "0645632569"
        assert item.ordered_nb == 4
        assert item2.ordered_nb == 1
        order = Order.objects.first()
        assert order.ordered_items.count() == 2
        assert order.articles_nb == 5

    def test_order_item__no_articles_ordered(self, client, other_user):
        """
        From the OrderDetailView, we order without having changed any item quantity.
        An error is raised.
        """
        grouped_order = create_grouped_order(
            days_before_delivery_date=5,
            days_before_deadline=2,
            name="gr order test",
            orga_user=other_user,
        )
        item = Item.objects.create(
            name="test item 1", grouped_order=grouped_order, price=1
        )
        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,
            {
                f"quantity_{item.pk}": 0,
                "first_name": "Prénom",
                "last_name": "Nom",
                "phone": "0645632569",
                "email": "test@mail.fr",
            },
        )
        order = Order.objects.first()
        order.articles_nb == 0
        assert response.status_code == 200
        assert (
            response.context["error_message"]
            == "Veuillez commander au moins un produit"
        )


class TestGroupedOrderOverview:
    def test_get_overview(self, client_log):
        """
        From the OrderDetailView, we order an item using the order form, and it creates an Order with an Ordered_item inside
        """
        grouped_order = create_grouped_order(
            days_before_delivery_date=5,
            days_before_deadline=2,
            name="gr order test",
            orga_user=auth.get_user(client_log),
        )
        item = Item.objects.create(
            name="test item 1", grouped_order=grouped_order, price=2
        )

        overview_url = reverse(
            "order:grouped_order_overview",
            kwargs={
                "pk": grouped_order.pk,
            },
        )
        # some items are ordered
        order_url = reverse(
            "order:order",
            kwargs={
                "grouped_order_id": grouped_order.pk,
            },
        )
        client_log.post(
            order_url,
            {
                f"quantity_{item.pk}": 4,
                "first_name": "Prénom",
                "last_name": "Nom",
                "phone": "0645632569",
                "email": "test@mail.fr",
            },
        )
        response = client_log.get(overview_url)
        assert response.status_code == 200
        assert "test item" in response.content.decode()
        assert "gr order test" in response.content.decode()
        item.refresh_from_db()
        assert item.get_total_price() == 8
        assert "8" in response.content.decode()

    def test_user_not_logged_redirect(self, client, other_user):
        """
        A user that is not logged cannot see the GroupedOrderOverview. They get redirected to the login view
        """
        grouped_order = create_grouped_order(
            days_before_delivery_date=5,
            days_before_deadline=2,
            name="gr order test",
            orga_user=other_user,
        )
        orga_view_url = reverse(
            "order:grouped_order_overview",
            kwargs={
                "pk": grouped_order.pk,
            },
        )
        assert auth.get_user(client).is_anonymous
        response = client.get(orga_view_url)
        assert response.status_code == 302
        assert response.url.startswith(reverse("accounts:login"))
        assert response.url.endswith(
            reverse(
                "order:grouped_order_overview",
                kwargs={
                    "pk": grouped_order.pk,
                },
            )
        )

    def test_user_not_orga_redirect(self, client_log, other_user):
        """
        A user that is not orga cannot see the GroupedOrderOverview.
        They get a 403 forbidden error
        """
        grouped_order = create_grouped_order(
            days_before_delivery_date=5,
            days_before_deadline=2,
            name="gr order test",
            orga_user=other_user,
        )
        orga_view_url = reverse(
            "order:grouped_order_overview",
            kwargs={
                "pk": grouped_order.pk,
            },
        )
        response = client_log.get(orga_view_url)
        assert response.status_code == 403


class TestGroupedOrderCreateView:
    def test_create_grouped_order(self, client_log):
        """
        A logged user gets the grouped order creation page, and creates a grouped order.
        They are redirected to the manage items page.
        """
        assert GroupedOrder.objects.count() == 0
        create_gorder_url = reverse("order:create_grouped_order")
        response = client_log.get(create_gorder_url)
        assert response.status_code == 200
        date = timezone.now().date() + datetime.timedelta(days=42)
        deadline = timezone.now() + datetime.timedelta(days=32)
        response = client_log.post(
            create_gorder_url,
            {"name": "titre test", "deadline": deadline, "delivery_date": date},
        )
        assert response.status_code == 302
        assert response.url.endswith("gerer-produits")
        assert GroupedOrder.objects.count() == 1

    def test_create_grouped_order__anonymous_user(self, client):
        create_gorder_url = reverse("order:create_grouped_order")
        response = client.get(create_gorder_url)
        assert response.status_code == 302
        assert response.url.startswith(reverse("accounts:login"))
        assert response.url.endswith(
            reverse(
                "order:create_grouped_order",
            )
        )


class TestGroupedOrderAddItemsView:
    def test_get_manage_items__user_not_orga(self, client_log, other_user):
        """
        A user that is not orga cannot see the GroupedOrderAddItemsView.
        They get a 403 forbidden error
        """
        grouped_order = create_grouped_order(
            days_before_delivery_date=5,
            days_before_deadline=2,
            name="gr order test",
            orga_user=other_user,
        )
        add_items_view_url = reverse(
            "order:manage_items",
            kwargs={
                "pk": grouped_order.pk,
            },
        )
        response = client_log.get(add_items_view_url)
        assert response.status_code == 403

    def test_get_manage_items__anonymous_user(self, client, other_user):
        """
        A user that is not logged cannot see the GroupedOrderOverview. They get redirected to the login view
        """
        grouped_order = create_grouped_order(
            days_before_delivery_date=5,
            days_before_deadline=2,
            name="gr order test",
            orga_user=other_user,
        )
        add_items_view_url = reverse(
            "order:manage_items",
            kwargs={
                "pk": grouped_order.pk,
            },
        )
        assert auth.get_user(client).is_anonymous
        response = client.get(add_items_view_url)
        assert response.status_code == 302
        assert response.url.startswith(reverse("accounts:login"))
        assert response.url.endswith(
            reverse(
                "order:manage_items",
                kwargs={
                    "pk": grouped_order.pk,
                },
            )
        )


class TestItemCreateView:
    def test_create_item(self, client_log):
        """A user that has created a grouped order adds an item to it."""
        grouped_order = create_grouped_order(
            days_before_delivery_date=5,
            days_before_deadline=2,
            name="gr order test",
            orga_user=auth.get_user(client_log),
        )
        create_item_view_url = reverse(
            "order:item_create",
            kwargs={
                "pk": grouped_order.pk,
            },
        )
        response = client_log.post(
            create_item_view_url, {"name": "titre item", "price": 2}
        )
        assert response.status_code == 302
        assert response.url == reverse(
            "order:manage_items",
            kwargs={
                "pk": grouped_order.pk,
            },
        )
        assert Item.objects.first().name == "titre item"
        response = client_log.get(response.url)
        assert "titre item" in response.content.decode()

    def test_create_item__anonymous_user(self, client, other_user):
        """
        A user that is not logged cannot create an item. They get a redirected to loginview.
        """
        grouped_order = create_grouped_order(
            days_before_delivery_date=5,
            days_before_deadline=2,
            name="gr order test",
            orga_user=other_user,
        )
        create_item_view_url = reverse(
            "order:item_create",
            kwargs={
                "pk": grouped_order.pk,
            },
        )
        response = client.post(create_item_view_url, {"name": "titre item"})
        assert response.status_code == 302
        assert (
            response.url == f"{reverse('accounts:login')}?next={create_item_view_url}"
        )

    def test_create_item__not_orga(self, client_log, other_user):
        """
        A user that is not orga cannot create an item. They get a 403 error.
        """
        grouped_order = create_grouped_order(
            days_before_delivery_date=5,
            days_before_deadline=2,
            name="gr order test",
            orga_user=other_user,
        )
        create_item_view_url = reverse(
            "order:item_create",
            kwargs={
                "pk": grouped_order.pk,
            },
        )
        response = client_log.post(create_item_view_url, {"name": "titre item"})
        assert response.status_code == 403