Revert breaking optimizations to FRT calculation

Reverts commits:
- e0c0d11
- 3f5c078
- a5c7034
- 91c43d5

Something in here breaks FRT in test server.
Revert changes until fix is found so that we can merge changes to prod.

Author: matti-lamppu

opening_hours/utils/time_span_element_utils.py

@@ -15,15 +15,13 @@ def merge_overlapping_time_span_elements(time_span_elements: list[TimeSpanElemen
 
     merged_time_span_elements: list[TimeSpanElement] = []
     for current_time_span in time_span_elements:
-        # If the `merged_time_span_elements` list is empty, simply append the current time span
+        # If the selected_list is empty, simply append the current time span
         if not merged_time_span_elements:
             merged_time_span_elements.append(current_time_span)
             continue
 
-        # If the `merged_time_span_elements` contains a time span that overlaps with the current time span, combine them
+        # If the selected_list contains a time span that overlaps with the current time span, combine them.
         # The only time span that can overlap with the current time span is the last time span in the list.
-        last_time_span = merged_time_span_elements[-1]
-
         # ┌────────────────────────┐
         # │ LEGEND                 │
         # │ █ = Reservation        │
@@ -32,7 +30,7 @@ def merge_overlapping_time_span_elements(time_span_elements: list[TimeSpanElemen
         # ├────────────────────────┼──────────────────────────────────────────┐
         # │  ████     ->  ███████  │ Overlapping                              │
         # │    █████  ->           │ The last time span is extended           │
-        # │                        │                                          │
+        # ├────────────────────────┼──────────────────────────────────────────┤
         # │  ████     ->  ███████  │ Current time span ends at the same time  │
         # │      ███  ->           │ as the last last time span ends.         │
         # │                        │ The last time span is extended           │
@@ -46,25 +44,35 @@ def merge_overlapping_time_span_elements(time_span_elements: list[TimeSpanElemen
         # │  ▄▄▄██▄▄  ->           │                                          │
         # ├────────────────────────┼──────────────────────────────────────────┤
         # │  ███████  ->  ███████  │ Time span is fully inside the last one   │
-        # │    ███    ->           │ Later can be skipped                     │
-        # │                        │                                          │
-        # │   █████   ->  ▄█████▄  │ Buffers extend outside earlier time span │
-        # │  ▄▄███▄▄  ->           │ The buffered start/end times are kept    │
+        # │    ███    ->           │                                          │
+        # │                        │ The buffered start/end times are kept    │
+        # │   █████   ->  ▄█████▄  │                                          │
+        # │  ▄▄███▄▄  ->           │                                          │
         # └────────────────────────┴──────────────────────────────────────────┘
-        # Last time span overlaps with the current time span, so they can be merged.
+        last_time_span = merged_time_span_elements[-1]
+
+        # Last time span overlaps with the current time span, combine them.
         if last_time_span.end_datetime >= current_time_span.start_datetime:
-            # Adjust the before buffer of the last time span
-            if current_time_span.buffer_time_before:
-                min_buffered_dt = min(last_time_span.buffered_start_datetime, current_time_span.buffered_start_datetime)
-                last_time_span.buffer_time_before = last_time_span.start_datetime - min_buffered_dt
+            # This time span is fully inside the last one.
+            if last_time_span.end_datetime > current_time_span.end_datetime:
+                # Even with after buffers, this time span is fully inside the last one, so it can be skipped.
+                if last_time_span.buffered_end_datetime > current_time_span.buffered_end_datetime:
+                    continue
+
+                # Current time span's buffer ends after the last's buffer ends, so we can extend the last's buffer.
+                buffer_delta = last_time_span.buffered_end_datetime - current_time_span.buffered_end_datetime
+                last_time_span.buffer_time_after += buffer_delta
+                continue
 
-            # Adjust the after buffer of the last time span
-            # If the current time span ends after the last time span ends, extend the last time span's end datetime.
+            # Extend the last time span's before buffer.
+            min_buffered_dt = min(last_time_span.buffered_start_datetime, current_time_span.buffered_start_datetime)
+            last_time_span.buffer_time_before = last_time_span.start_datetime - min_buffered_dt
+
+            # Extend the last time span and it's after buffer.
+            # The buffered end datetime should stay the same.
             max_buffered_dt = max(last_time_span.buffered_end_datetime, current_time_span.buffered_end_datetime)
-            last_time_span.end_datetime = max(last_time_span.end_datetime, current_time_span.end_datetime)
+            last_time_span.end_datetime = current_time_span.end_datetime
             last_time_span.buffer_time_after = max_buffered_dt - last_time_span.end_datetime
-
-            # The current time span is discarded after the above adjustments.
             continue
 
         # No overlapping time spans, check for overlapping buffers and add the current time span to the merged list.

reservation_units/utils/first_reservable_time_helper/first_reservable_time_reservable_time_span_helper.py

@@ -43,16 +43,14 @@ def calculate_first_reservable_time(self) -> ReservableTimeOutput:
         if not normalised_time_spans:
             return ReservableTimeOutput(is_closed=True, first_reservable_time=None)
 
-        # For minimal performance gains this should only be run once; the first time we know the ReservationUnit is open
-        if self.parent.is_reservation_unit_closed:
-            # At this point we know that the ReservationUnit is OPEN.
-            # Now that we know if the ReservationUnit is OPEN, Validate `reservation_unit.max_reservation_duration`.
-            if self.parent.is_reservation_unit_max_duration_invalid:
-                return ReservableTimeOutput(is_closed=False, first_reservable_time=None)
+        # At this point we know that the ReservationUnit is OPEN.
+        # Now that we know if the ReservationUnit is OPEN, Validate `reservation_unit.max_reservation_duration`.
+        if self.parent.is_reservation_unit_max_duration_invalid:
+            return ReservableTimeOutput(is_closed=False, first_reservable_time=None)
 
-            normalised_time_spans = self._soft_normalise_time_span(normalised_time_spans)
-            if not normalised_time_spans:
-                return ReservableTimeOutput(is_closed=False, first_reservable_time=None)
+        normalised_time_spans = self._soft_normalise_time_span(normalised_time_spans)
+        if not normalised_time_spans:
+            return ReservableTimeOutput(is_closed=False, first_reservable_time=None)
 
         # At this point we have removed all the closed time spans from the reservable time span.
         # Finally, try to find the first reservable time span from the left over reservable time spans.
@@ -65,12 +63,14 @@ def calculate_first_reservable_time(self) -> ReservableTimeOutput:
 
     def _hard_normalise_time_span(self, current_time_span: TimeSpanElement) -> list[TimeSpanElement]:
         """Remove Hard-Closed time spans from a TimeSpanElement."""
-        combined_hard_closed_time_spans: list[TimeSpanElement] = (
-            self.parent.hard_closed_time_spans
-            + current_time_span.generate_closed_time_spans_outside_filter(
-                filter_time_start=self.parent.parent.filter_time_start,
-                filter_time_end=self.parent.parent.filter_time_end,
-            )
+        combined_hard_closed_time_spans: list[TimeSpanElement] = []
+
+        # Add hard closed time spans from the ReservationUnit
+        combined_hard_closed_time_spans += self.parent.hard_closed_time_spans
+        # Add hard closed time spans from the ReservableTimeSpan
+        combined_hard_closed_time_spans += current_time_span.generate_closed_time_spans_outside_filter(
+            filter_time_start=self.parent.parent.filter_time_start,
+            filter_time_end=self.parent.parent.filter_time_end,
         )
 
         return override_reservable_with_closed_time_spans(

reservation_units/utils/first_reservable_time_helper/first_reservable_time_reservation_unit_helper.py

@@ -54,24 +54,22 @@ class ReservationUnitFirstReservableTimeHelper:
 
     is_reservation_unit_max_duration_invalid: bool
 
-    is_reservation_unit_closed: bool
-
     def __init__(self, parent: FirstReservableTimeHelper, reservation_unit: ReservationUnit) -> None:
         self.parent = parent
         self.reservation_unit = reservation_unit
 
-        self.hard_closed_time_spans = self._merge_time_spans(
-            self._get_hard_closed_time_spans() + parent.shared_hard_closed_time_spans
-        )
+        self.hard_closed_time_spans = self._get_hard_closed_time_spans()
+        self.hard_closed_time_spans += parent.shared_hard_closed_time_spans
+        self.hard_closed_time_spans = self._merge_time_spans(self.hard_closed_time_spans)
 
-        self.reservation_closed_time_spans = self._merge_time_spans(self._get_reservation_closed_time_spans())
+        self.reservation_closed_time_spans = self._get_reservation_closed_time_spans()
+        self.reservation_closed_time_spans = self._merge_time_spans(self.reservation_closed_time_spans)
         self.blocking_reservation_closed_time_spans = self._get_blocking_reservation_closed_time_spans()
 
-        self.soft_closed_time_spans = self._merge_time_spans(
-            self._get_soft_closed_time_spans()
-            + self.reservation_closed_time_spans
-            + self.blocking_reservation_closed_time_spans
-        )
+        self.soft_closed_time_spans = self._get_soft_closed_time_spans()
+        self.soft_closed_time_spans += self.reservation_closed_time_spans
+        self.soft_closed_time_spans += self.blocking_reservation_closed_time_spans
+        self.soft_closed_time_spans = self._merge_time_spans(self.soft_closed_time_spans)
 
         start_interval_minutes = ReservationStartInterval(reservation_unit.reservation_start_interval).as_number
 
@@ -97,35 +95,22 @@ def _merge_time_spans(time_spans) -> list[TimeSpanElement]:
         return merge_overlapping_time_span_elements(sorted(time_spans, key=lambda time_span: time_span.start_datetime))
 
     def calculate_first_reservable_time(self) -> ReservableTimeOutput:
-        self.is_reservation_unit_closed = True
+        is_closed = True
 
         # Go through each ReservableTimeSpan individually one-by-one until a suitable time span is found.
         for reservable_time_span in self.reservation_unit.origin_hauki_resource.reservable_time_spans.all():
             helper = ReservableTimeSpanFirstReservableTimeHelper(parent=self, reservable_time_span=reservable_time_span)
             output = helper.calculate_first_reservable_time()
 
+            # The ReservationUnit is not closed. Save the value in case we don't find a first reservable time.
+            if output.is_closed is False:
+                is_closed = False
+
             # If we have found a first reservable time, we can return early
             if output.first_reservable_time is not None:
                 return output
 
-            # The ReservationUnit is not closed. Save the value in case we don't find a first reservable time.
-            if not output.is_closed and self.is_reservation_unit_closed:
-                self.is_reservation_unit_closed = False
-
-                # Now that we know that the ReservationUnit is not closed,
-                # we can exit early if the maximum duration is invalid.
-                if self.is_reservation_unit_max_duration_invalid:
-                    return output
-
-                # We don't have a first reservable time, but we know that the ReservationUnit is not closed.
-                # Merge the soft closed time spans with the hard closed time spans, so that all future time spans are
-                # faster to find as we hopefully have less overlapping closed time spans that need to be looped through.
-                self.hard_closed_time_spans = self._merge_time_spans(
-                    self.hard_closed_time_spans + self.soft_closed_time_spans
-                )
-                self.soft_closed_time_spans = []
-
-        return ReservableTimeOutput(is_closed=self.is_reservation_unit_closed, first_reservable_time=None)
+        return ReservableTimeOutput(is_closed=is_closed, first_reservable_time=None)
 
     def _get_hard_closed_time_spans(self) -> list[TimeSpanElement]:
         """