import re

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

from la_chariotte.order import models

from .utils import create_grouped_order, order_items_in_grouped_order

pytestmark = pytest.mark.django_db


class TestPlaceOverviewView:
    def test_overview_place(self, client_log):
        """A user checks out a place successfully"""
        place = models.Place.objects.create(
            name="foo",
            orga=auth.get_user(client_log),
            code="foo",
        )

        overview_place_view_url = reverse(
            "order:place_overview",
            kwargs={
                "code": place.code,
            },
        )

        response = client_log.get(overview_place_view_url)
        assert response.status_code == 200

        body = response.content.decode()
        assert "foo: Commandes groupées"
        assert "Aucune commande groupée en cours"

    def test_overview_with_orders(self, client_log):
        """A user checks out a place with several orders"""
        place = models.Place.objects.create(
            name="foo",
            orga=auth.get_user(client_log),
            code="foo",
        )

        overview_place_view_url = reverse(
            "order:place_overview",
            kwargs={
                "code": place.code,
            },
        )

        grouped_order1 = create_grouped_order(
            31, 30, "firstorder", auth.get_user(client_log)
        )
        grouped_order1.places.add(place)
        grouped_order2 = create_grouped_order(
            31, 30, "secondorder", auth.get_user(client_log)
        )
        grouped_order2.places.add(place)

        # Generate some items
        order = order_items_in_grouped_order(grouped_order1, place=place)

        response = client_log.get(overview_place_view_url)
        assert response.status_code == 200

        body = response.content.decode()
        assert "foo: Commandes groupées"
        assert "foo (2 commandes groupées en cours)" in body
        assert '">firstorder</a> (2 produits)' in body
        assert '">secondorder</a> (0 produit)' in body

    def test_overview_place__anonymous_user(self, client, other_user):
        """
        A user that is not logged can check out a place
        """
        place = models.Place.objects.create(
            name="foo",
            orga=other_user,
            code="foo",
        )

        overview_place_view_url = reverse(
            "order:place_overview",
            kwargs={
                "code": place.code,
            },
        )

        response = client.get(overview_place_view_url)
        assert response.status_code == 200

        body = response.content.decode()
        assert "foo: Commandes groupées"
        assert "Aucune commande groupée en cours"


class TestPlaceUpdateView:
    def test_update_place(self, client_log):
        """A user updates their place successfully"""
        place = models.Place.objects.create(
            name="foo",
            orga=auth.get_user(client_log),
            code="foo",
        )

        update_place_view_url = reverse(
            "order:place_update",
            kwargs={
                "code": place.code,
            },
        )

        overview_place_view_url = reverse(
            "order:place_overview",
            kwargs={
                "code": place.code,
            },
        )

        response = client_log.post(
            update_place_view_url,
            {
                "name": "bar",
                "description": "longer bar",
                "code": place.code,
            },
        )

        assert response.status_code == 302
        assert response.url == overview_place_view_url

        place = models.Place.objects.all().filter(code=place.code).first()

        assert place.name == "bar"
        assert place.description == "longer bar"
        assert place.code == "foo"

    def test_update_place_code_silently_fails(self, client_log):
        """A user tries to change a place's identifier, which fails because it's immutable"""
        place = models.Place.objects.create(
            name="foo",
            orga=auth.get_user(client_log),
            code="foo",
        )

        update_place_view_url = reverse(
            "order:place_update",
            kwargs={
                "code": place.code,
            },
        )

        response = client_log.post(
            update_place_view_url,
            {
                "name": "bar",
                "description": "longer bar",
                "code": "newcode",
            },
        )

        # Ideally, response should look successful, but not alter the place's code
        # But for now this just returns 404
        assert response.content.decode() == ""
        assert response.status_code == 302

        place = models.Place.objects.all().filter(code=place.code).first()

        assert place.name == "bar"
        assert place.description == "longer bar"
        assert place.code == "foo"

    def test_update_place_does_not_exist_fails(self, client_log):
        """A user tries to update a place which does not exist, which fails"""
        place = models.Place.objects.create(
            name="foo",
            orga=auth.get_user(client_log),
            code="foo",
        )

        update_place_view_url = reverse(
            "order:place_update",
            kwargs={
                "code": "notfoo",
            },
        )

        response = client_log.post(
            update_place_view_url,
            {
                "name": "bar",
                "description": "longer bar",
                "code": "newcode",
            },
        )

        # Response should look successful, but not alter the place's code
        assert response.status_code == 404

        place = models.Place.objects.all().filter(code=place.code).first()

        assert place.name == "foo"
        assert place.description == None
        assert place.code == "foo"

    def test_update_place__not_orga(self, client_log, other_user):
        """
        A user that is not orga cannot edit a place. They get a 403 error.
        """
        place = models.Place.objects.create(
            name="foo",
            code="foo",
            orga=other_user,
        )

        update_place_view_url = reverse(
            "order:place_update",
            kwargs={
                "code": "foo",
            },
        )
        response = client_log.post(
            update_place_view_url, {"name": "notfoo", "code": "foo"}
        )
        assert response.status_code == 403


class TestPlaceCreateView:
    def test_create_place(self, client_log):
        """A user creates a new place."""
        create_place_view_url = reverse(
            "order:place_create",
        )
        response = client_log.post(
            create_place_view_url, {"name": "foo", "code": "foo"}
        )
        assert response.status_code == 302
        assert response.url == reverse(
            "order:place_index",
        )
        assert models.Place.objects.first().name == "foo"
        response = client_log.get(response.url)
        assert "foo" in response.content.decode()

    def test_create_place__anonymous_user(self, client, other_user):
        """
        A user that is not logged cannot create a place. They get a redirected to loginview.
        """
        create_place_view_url = reverse(
            "order:place_create",
        )
        response = client.post(create_place_view_url, {"name": "foo", "code": "foo"})
        assert response.status_code == 302
        assert (
            response.url == f"{reverse('accounts:login')}?next={create_place_view_url}"
        )

    def test_create_place__already_exists(self, client_log):
        """A user creates a new place whose code already exists. It fails"""
        create_place_view_url = reverse(
            "order:place_create",
        )
        response = client_log.post(
            create_place_view_url, {"name": "foo", "code": "foo"}
        )
        # TODO: is this correct????
        assert response.status_code == 302
        assert response.url == reverse(
            "order:place_index",
        )
        assert models.Place.objects.first().name == "foo"
        response = client_log.get(response.url)
        assert "foo" in response.content.decode()


class TestPlaceIndexView:
    def test_index_place(self, client_log):
        """A user lists their places."""
        place1 = models.Place.objects.create(
            name="foo",
            code="foo",
            orga=auth.get_user(client_log),
        )
        place2 = models.Place.objects.create(
            name="bar",
            code="bar",
            orga=auth.get_user(client_log),
        )
        index_place_view_url = reverse(
            "order:place_index",
        )
        response = client_log.get(index_place_view_url)
        assert response.status_code == 200

        body = response.content.decode()

        place1_overview_view_url = reverse(
            "order:place_overview",
            kwargs={
                "code": place1.code,
            },
        )
        place2_overview_view_url = reverse(
            "order:place_overview",
            kwargs={
                "code": place2.code,
            },
        )

        place1_update_view_url = reverse(
            "order:place_update",
            kwargs={
                "code": place1.code,
            },
        )
        place2_update_view_url = reverse(
            "order:place_update",
            kwargs={
                "code": place2.code,
            },
        )

        assert place1_overview_view_url in body
        assert place1_update_view_url in body
        assert place2_overview_view_url in body
        assert place2_update_view_url in body

    def test_index_place_active_order(self, client_log):
        """A user lists their places, only one has an active order. Inactive orders are not shown."""
        place1 = models.Place.objects.create(
            name="foo",
            code="foo",
            orga=auth.get_user(client_log),
        )
        place2 = models.Place.objects.create(
            name="bar",
            code="bar",
            orga=auth.get_user(client_log),
        )
        grouped_order1 = create_grouped_order(
            31, 30, "order", auth.get_user(client_log)
        )
        grouped_order1.places.add(place1)
        grouped_order2 = create_grouped_order(
            -2, -1, "inactive_order", auth.get_user(client_log)
        )
        grouped_order2.places.add(place1)

        index_place_view_url = reverse(
            "order:place_index",
        )
        response = client_log.get(index_place_view_url)
        assert response.status_code == 200

        body = response.content.decode()

        place1_overview_view_url = reverse(
            "order:place_overview",
            kwargs={
                "code": place1.code,
            },
        )
        place2_overview_view_url = reverse(
            "order:place_overview",
            kwargs={
                "code": place2.code,
            },
        )

        place1_update_view_url = reverse(
            "order:place_update",
            kwargs={
                "code": place1.code,
            },
        )
        place2_update_view_url = reverse(
            "order:place_update",
            kwargs={
                "code": place2.code,
            },
        )

        grouped_order1_detail_view_url = reverse(
            "order:grouped_order_detail",
            kwargs={
                "code": grouped_order1.code,
            },
        )
        grouped_order2_detail_view_url = reverse(
            "order:grouped_order_detail",
            kwargs={
                "code": grouped_order2.code,
            },
        )

        assert place1_overview_view_url in body
        assert place1_update_view_url in body
        assert grouped_order1_detail_view_url in body
        assert place2_overview_view_url in body
        assert place2_update_view_url in body

        # Inactive order is not displayed
        assert "inactive_order" not in body
        assert str(grouped_order2_detail_view_url) not in body

    def test_index_place_active_order_in_correct_order(self, client_log):
        """A user lists their places. One has two active orders. The latest delivery date is displayed first."""
        place = models.Place.objects.create(
            name="foo",
            code="foo",
            orga=auth.get_user(client_log),
        )
        grouped_order1 = create_grouped_order(
            31, 30, "order", auth.get_user(client_log)
        )
        grouped_order1.places.add(place)
        grouped_order2 = create_grouped_order(
            61, 60, "more_recent_order", auth.get_user(client_log)
        )
        grouped_order2.places.add(place)

        index_place_view_url = reverse(
            "order:place_index",
        )
        response = client_log.get(index_place_view_url)
        assert response.status_code == 200

        body = response.content.decode()

        place_update_view_url = reverse(
            "order:place_update",
            kwargs={
                "code": place.code,
            },
        )

        place_overview_view_url = reverse(
            "order:place_overview",
            kwargs={
                "code": place.code,
            },
        )

        grouped_order1_detail_view_url = reverse(
            "order:grouped_order_detail",
            kwargs={
                "code": grouped_order1.code,
            },
        )
        grouped_order2_detail_view_url = reverse(
            "order:grouped_order_detail",
            kwargs={
                "code": grouped_order2.code,
            },
        )

        assert place_overview_view_url in body
        assert place_update_view_url in body
        assert grouped_order1_detail_view_url in body
        assert grouped_order2_detail_view_url in body

    def test_index_place__not_orga(self, client_log, other_user):
        """
        A user that is not orga cannot view places they don't own.
        """
        place = models.Place.objects.create(
            name="NOTMYPLACE",
            code="NOTMYPLACE",
            orga=other_user,
        )

        update_place_view_url = reverse(
            "order:place_update",
            kwargs={
                "code": "NOTMYPLACE",
            },
        )

        index_place_view_url = reverse(
            "order:place_index",
        )

        response = client_log.get(index_place_view_url)
        assert response.status_code == 200

        body = response.content.decode()
        assert place.name not in body
        assert update_place_view_url not in body