import operator
from dataclasses import dataclass
from functools import reduce
from typing import Optional, ClassVar

from django.db.models import Q, F
from django.utils.translation import gettext_lazy as _
from ninja.errors import ValidationError
from shapely import Point, LineString
from shapely.geometry import mapping

from c3nav.mapdata.forms import I18nModelFormMixin
from c3nav.mapdata.models import Space, GraphEdge
from c3nav.mapdata.models.geometry.space import LeaveDescription, CrossDescription
from c3nav.mapdata.quests.base import ChangeSetModelForm, register_quest, Quest
from c3nav.mapdata.utils.geometry import unwrap_geom


class SpaceIdentifyableQuestForm(ChangeSetModelForm):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields["identifyable"].label = _("Does this space qualify as “easily identifyable/findable”?")
        self.fields["identifyable"].help_text = ""
        self.fields["identifyable"].required = True

    class Meta:
        model = Space
        fields = ("identifyable", )

    def save(self, *args, **kwargs):
        self.instance.altitude_quest = False
        return super().save(*args, **kwargs)

    @property
    def changeset_title(self):
        return f'Altitude Quest: {self.instance.title}'


@register_quest
@dataclass
class SpaceIdentifyableQuest(Quest):
    quest_type = "space_identifyable"
    quest_type_label = _('Space identifyability')
    quest_type_icon = "beenhere"
    form_class = SpaceIdentifyableQuestForm
    obj: Space

    @property
    def quest_description(self) -> list[str]:
        return [
            _("If you are standing in any adjacent space to this one and you know that this space is named “%s”, "
              "will it be very straightforward to find it?") % self.obj.title,
            _("This applies mainly to rooms that are connected to a corridor where, if you pass their door, you will, "
              "thanks to a sign or other some other labeling, immediately able to tell that this is the door you want "
              "to go through."),
            _("Also, obviously, if this is a side room to another room, like a bathroom in a wardrobe."),
            _("If finding this space from adjacent spaces is not obvious, the answer is no."),
            _("Even if it's a bathroom or similar facility, the answer is no unless it is very obvious and easy to see"
              " where it is."),
        ]

    @property
    def point(self) -> Point:
        return mapping(self.obj.point)

    @classmethod
    def _qs_for_request(cls, request):
        return Space.qs_for_request(request).select_related('level').filter(identifyable=None)


def get_door_edges_for_request(request, space_ids: Optional[list[int]] = None):
    qs = Space.qs_for_request(request)
    if space_ids:
        qs = qs.filter(pk__in=space_ids)
    spaces = {space.pk: space for space in qs.select_related("level")}
    existing = set(tuple(item) for item in LeaveDescription.objects.values_list("space_id", "target_space_id"))

    qs = GraphEdge.objects.filter(
        from_node__space__in=spaces,
        to_node__space__in=spaces,
        waytype=None,
    )
    if space_ids:
        qs = qs.filter(reduce(operator.or_, (Q(from_node__space_id=space_ids[i], to_node__space_id=space_ids[i+1])
                                             for i in range(len(space_ids) - 1))))
    return spaces, {
        (from_space, to_space): (from_point, to_point)
        for from_space, to_space, from_point, to_point in qs.exclude(
            from_node__space=F("to_node__space")
        ).values_list("from_node__space_id", "to_node__space_id", "from_node__geometry", "to_node__geometry")
        if (from_space, to_space) not in existing
    }


class LeaveDescriptionQuestForm(I18nModelFormMixin, ChangeSetModelForm):
    class Meta:
        model = LeaveDescription
        fields = ("description", )

    @property
    def changeset_title(self):
        return f'LeaveDesscription Quest: {self.instance.space.title} → {self.instance.target_space.title}'


@register_quest
@dataclass
class LeaveDescriptionQuest(Quest):
    quest_type = "leave_description"
    quest_type_label = _('Leave Description')
    quest_type_icon = "logout"
    form_class = LeaveDescriptionQuestForm
    obj: ClassVar
    space: Space
    target_space: Space
    the_point: Point

    @property
    def quest_description(self) -> list[str]:
        return [
            _("Please provide a description to be used when leaving “%(from_space)s” towards “%(to_space)s”.") % {
                "from_space": self.space.title,
                "to_space": self.target_space.title,
            },
            _("This will be used all for all connections that lead from this space to the other, not just the "
              "highlighted one! So, if there is more than one connection between these two rooms, please be generic."),
            _("The description should make it possible to find the room exit no matter where in the room you are."),
            _("Examples: “Walk through the red door.”, „Walk through the doors with the Sign “Hall 3” above it.”"),
        ]

    @property
    def point(self) -> dict:
        return mapping(self.the_point)

    @property
    def level_id(self) -> int:
        return self.space.level.on_top_of_id or self.space.level_id

    @property
    def identifier(self) -> str:
        return f"{self.space.pk}-{self.target_space.pk}"

    @classmethod
    def get_all_for_request(cls, request, space_ids: tuple[int, int] = ()):
        spaces, edges = get_door_edges_for_request(request, space_ids)
        return [
            cls(
                space=spaces[from_space],
                target_space=spaces[to_space],
                the_point=unwrap_geom(from_point),
            )
            for (from_space, to_space), (from_point, to_point) in edges.items()
            if spaces[to_space].identifyable is False
        ]

    @classmethod
    def get_for_request(cls, request, identifier: str):
        space_ids = identifier.split('-')
        if len(space_ids) != 2 or not all(i.isdigit() for i in space_ids):
            return None

        results = cls.get_all_for_request(request, space_ids=[int(i) for i in space_ids])
        return results[0] if results else None

    def get_form_kwargs(self, request):
        instance = LeaveDescription()
        instance.space = self.space
        instance.target_space = self.target_space
        return {"instance": instance}


class CrossDescriptionQuestForm(I18nModelFormMixin, ChangeSetModelForm):
    class Meta:
        model = CrossDescription
        fields = ("description", )

    @property
    def changeset_title(self):
        return f'CrossDesscription Quest: {self.instance.origin_space.title} → {self.instance.space.title} → {self.instance.target_space.title}'


@register_quest
@dataclass
class CrossDescriptionQuest(Quest):
    quest_type = "cross_description"
    quest_type_label = _('Cross Description')
    quest_type_icon = "roundabout_right"
    form_class = CrossDescriptionQuestForm
    obj: ClassVar
    space: Space
    origin_space: Space
    target_space: Space
    the_point: Point

    @property
    def quest_description(self) -> list[str]:
        return [
            _("Please provide a description to be used when coming from “%(from_space)s” into “%(space)s” and exiting towardss “%(to_space)s”.") % {
                "from_space": self.origin_space.title,
                "space": self.space.title,
                "to_space": self.target_space.title,
            },
            _("This will be used combination of space connections that match this description, not just the "
              "highlighted ones! So, if there is more than connection between these two rooms, please be generic."),
            _("This description will replace the entire route descripting when passing through the room this way."),
            _("Examples: “Go straight ahead into the room right across.” “Turn right and go through the big doors.”"),
        ]

    @property
    def point(self) -> dict:
        return mapping(self.the_point)

    @property
    def level_id(self) -> int:
        return self.space.level.on_top_of_id or self.space.level_id

    @property
    def identifier(self) -> str:
        return f"{self.origin_space.pk}-{self.space.pk}-{self.target_space.pk}"

    @classmethod
    def get_all_for_request(cls, request, space_ids: Optional[list[int]] = None):
        spaces, edges = get_door_edges_for_request(request, space_ids)
        from_space_conns = {}
        for (from_space, to_space), (from_point, to_point) in edges.items():
            from_space_conns.setdefault(from_space, []).append((to_space, from_point))

        results = []
        for (origin_space, space), (first_point, origin_point) in edges.items():
            for target_space, target_point in from_space_conns.get(space, ()):
                if not (spaces[target_space].identifyable is False):
                    continue
                line = LineString([origin_point, target_point])
                the_point = line.interpolate(0.33, normalized=True) if line.length < 3 else line.interpolate(1)
                results.append(cls(
                    space=spaces[space],
                    origin_space=spaces[origin_space],
                    target_space=spaces[target_space],
                    the_point=the_point,
                ))
        return results

    @classmethod
    def get_for_request(cls, request, identifier: str):
        space_ids = identifier.split('-')
        if len(space_ids) != 3 or not (space_ids[0].isdigit() and space_ids[1].isdigit()):
            return None

        results = cls.get_all_for_request(request, space_ids=tuple(int(i) for i in space_ids))
        return results[0] if results else None

    def get_form_kwargs(self, request):
        instance = LeaveDescription()
        instance.space = self.space
        instance.origin_space = self.origin_space
        instance.target_space = self.target_space
        return {"instance": instance}