multimodalsim-viewer 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

multimodalsim_viewer/server/simulation_visualization_data_model.py

@@ -1,1693 +1,1570 @@
-import json
-import math
-import os
-from enum import Enum
-
-import multimodalsim.optimization.dispatcher  # To avoid circular import error
-from filelock import FileLock
-from multimodalsim.simulator.environment import Environment
-from multimodalsim.simulator.request import Leg, Trip
-from multimodalsim.simulator.stop import Stop
-from multimodalsim.simulator.vehicle import Route, Vehicle
-from multimodalsim.state_machine.status import PassengerStatus, VehicleStatus
-from multimodalsim_viewer.server.server_utils import (
-    SAVE_VERSION,
-    SIMULATION_SAVE_FILE_SEPARATOR,
-)
-
-
-# MARK: Enums
-def convert_passenger_status_to_string(status: PassengerStatus) -> str:
-    if status == PassengerStatus.RELEASE:
-        return "release"
-    elif status == PassengerStatus.ASSIGNED:
-        return "assigned"
-    elif status == PassengerStatus.READY:
-        return "ready"
-    elif status == PassengerStatus.ONBOARD:
-        return "onboard"
-    elif status == PassengerStatus.COMPLETE:
-        return "complete"
-    else:
-        raise ValueError(f"Unknown PassengerStatus {status}")
-
-
-def convert_vehicle_status_to_string(status: VehicleStatus) -> str:
-    if status == VehicleStatus.RELEASE:
-        return "release"
-    elif status == VehicleStatus.IDLE:
-        return "idle"
-    elif status == VehicleStatus.BOARDING:
-        return "boarding"
-    elif status == VehicleStatus.ENROUTE:
-        return "enroute"
-    elif status == VehicleStatus.ALIGHTING:
-        return "alighting"
-    elif status == VehicleStatus.COMPLETE:
-        return "complete"
-    else:
-        raise ValueError(f"Unknown VehicleStatus {status}")
-
-
-def convert_string_to_passenger_status(status: str) -> PassengerStatus:
-    if status == "release":
-        return PassengerStatus.RELEASE
-    elif status == "assigned":
-        return PassengerStatus.ASSIGNED
-    elif status == "ready":
-        return PassengerStatus.READY
-    elif status == "onboard":
-        return PassengerStatus.ONBOARD
-    elif status == "complete":
-        return PassengerStatus.COMPLETE
-    else:
-        raise ValueError(f"Unknown PassengerStatus {status}")
-
-
-def convert_string_to_vehicle_status(status: str) -> VehicleStatus:
-    if status == "release":
-        return VehicleStatus.RELEASE
-    elif status == "idle":
-        return VehicleStatus.IDLE
-    elif status == "boarding":
-        return VehicleStatus.BOARDING
-    elif status == "enroute":
-        return VehicleStatus.ENROUTE
-    elif status == "alighting":
-        return VehicleStatus.ALIGHTING
-    elif status == "complete":
-        return VehicleStatus.COMPLETE
-    else:
-        raise ValueError(f"Unknown VehicleStatus {status}")
-
-
-# MARK: Serializable
-class Serializable:
-    def serialize(self) -> dict:
-        raise NotImplementedError()
-
-    @staticmethod
-    def deserialize(data: str) -> "Serializable":
-        """
-        Deserialize a dictionary into an instance of the class.
-
-        If the dictionary is not valid, return None.
-        """
-        raise NotImplementedError()
-
-
-# MARK: Leg
-class VisualizedLeg(Serializable):
-    assigned_vehicle_id: str | None
-    boarding_stop_index: int | None
-    alighting_stop_index: int | None
-    boarding_time: float | None
-    alighting_time: float | None
-    assigned_time: float | None
-
-    def __init__(
-        self,
-        assigned_vehicle_id: str | None,
-        boarding_stop_index: int | None,
-        alighting_stop_index: int | None,
-        boarding_time: float | None,
-        alighting_time: float | None,
-        assigned_time: float | None,
-    ) -> None:
-        self.assigned_vehicle_id = assigned_vehicle_id
-        self.boarding_stop_index = boarding_stop_index
-        self.alighting_stop_index = alighting_stop_index
-        self.boarding_time = boarding_time
-        self.alighting_time = alighting_time
-        self.assigned_time = assigned_time
-
-    @classmethod
-    def from_leg_environment_and_trip(
-        cls,
-        leg: Leg,
-        environment: Environment,
-        trip: Trip,
-        previous_leg: Leg | None = None,
-    ) -> "VisualizedLeg":
-        boarding_stop_index = None
-        alighting_stop_index = None
-
-        route = (
-            environment.get_route_by_vehicle_id(leg.assigned_vehicle.id)
-            if leg.assigned_vehicle is not None
-            else None
-        )
-
-        all_legs = (
-            trip.previous_legs
-            + ([trip.current_leg] if trip.current_leg else [])
-            + trip.next_legs
-        )
-
-        same_vehicle_leg_index = 0
-        for i, other_leg in enumerate(all_legs):
-            if other_leg.assigned_vehicle == leg.assigned_vehicle:
-                if other_leg == leg:
-                    break
-                else:
-                    same_vehicle_leg_index += 1
-
-        if route is not None:
-            all_stops = route.previous_stops.copy()
-            if route.current_stop is not None:
-                all_stops.append(route.current_stop)
-            all_stops += route.next_stops
-
-            trip_found_count = 0
-
-            for i, stop in enumerate(all_stops):
-                if boarding_stop_index is None and trip in (
-                    stop.passengers_to_board
-                    + stop.boarding_passengers
-                    + stop.boarded_passengers
-                ):
-                    if trip_found_count == same_vehicle_leg_index:
-                        boarding_stop_index = i
-                        break
-                    trip_found_count += 1
-
-            trip_found_count = 0
-
-            for i, stop in enumerate(all_stops):
-                if alighting_stop_index is None and trip in (
-                    stop.passengers_to_alight
-                    + stop.alighting_passengers
-                    + stop.alighted_passengers
-                ):
-                    if trip_found_count == same_vehicle_leg_index:
-                        alighting_stop_index = i
-                        break
-                    trip_found_count += 1
-
-        assigned_vehicle_id = (
-            leg.assigned_vehicle.id if leg.assigned_vehicle is not None else None
-        )
-
-        assigned_time = None
-        if assigned_vehicle_id is not None:
-            if previous_leg is not None and previous_leg.assigned_time is not None:
-                assigned_time = previous_leg.assigned_time
-            else:
-                assigned_time = environment.current_time
-
-        return cls(
-            assigned_vehicle_id,
-            boarding_stop_index,
-            alighting_stop_index,
-            leg.boarding_time,
-            leg.alighting_time,
-            assigned_time,
-        )
-
-    def serialize(self) -> dict:
-        serialized = {}
-
-        if self.assigned_vehicle_id is not None:
-            serialized["assignedVehicleId"] = self.assigned_vehicle_id
-
-        if self.boarding_stop_index is not None:
-            serialized["boardingStopIndex"] = self.boarding_stop_index
-
-        if self.alighting_stop_index is not None:
-            serialized["alightingStopIndex"] = self.alighting_stop_index
-
-        if self.boarding_time is not None:
-            serialized["boardingTime"] = self.boarding_time
-
-        if self.alighting_time is not None:
-            serialized["alightingTime"] = self.alighting_time
-        if self.assigned_time is not None:
-            serialized["assignedTime"] = self.assigned_time
-
-        return serialized
-
-    @staticmethod
-    def deserialize(data: str) -> "VisualizedLeg":
-        if isinstance(data, str):
-            data = json.loads(data.replace("'", '"'))
-
-        assigned_vehicle_id = data.get("assignedVehicleId", None)
-        boarding_stop_index = data.get("boardingStopIndex", None)
-        alighting_stop_index = data.get("alightingStopIndex", None)
-        boarding_time = data.get("boardingTime", None)
-        alighting_time = data.get("alightingTime", None)
-        assigned_time = data.get("assignedTime", None)
-
-        return VisualizedLeg(
-            assigned_vehicle_id,
-            boarding_stop_index,
-            alighting_stop_index,
-            boarding_time,
-            alighting_time,
-            assigned_time,
-        )
-
-
-# MARK: Passenger
-class VisualizedPassenger(Serializable):
-    passenger_id: str
-    name: str | None
-    status: PassengerStatus
-    number_of_passengers: int
-
-    previous_legs: list[VisualizedLeg]
-    current_leg: VisualizedLeg | None
-    next_legs: list[VisualizedLeg]
-
-    def __init__(
-        self,
-        passenger_id: str,
-        name: str | None,
-        status: PassengerStatus,
-        number_of_passengers: int,
-        previous_legs: list[VisualizedLeg],
-        current_leg: VisualizedLeg | None,
-        next_legs: list[VisualizedLeg],
-    ) -> None:
-        self.passenger_id = passenger_id
-        self.name = name
-        self.status = status
-        self.number_of_passengers = number_of_passengers
-
-        self.previous_legs = previous_legs
-        self.current_leg = current_leg
-        self.next_legs = next_legs
-
-    @classmethod
-    def from_trip_and_environment(
-        cls, trip: Trip, environment: Environment
-    ) -> "VisualizedPassenger":
-        previous_legs = [
-            VisualizedLeg.from_leg_environment_and_trip(leg, environment, trip)
-            for leg in trip.previous_legs
-        ]
-        current_leg = (
-            VisualizedLeg.from_leg_environment_and_trip(
-                trip.current_leg, environment, trip
-            )
-            if trip.current_leg is not None
-            else None
-        )
-        next_legs = [
-            VisualizedLeg.from_leg_environment_and_trip(leg, environment, trip)
-            for leg in trip.next_legs
-        ]
-
-        return cls(
-            trip.id,
-            trip.name,
-            trip.status,
-            trip.nb_passengers,
-            previous_legs,
-            current_leg,
-            next_legs,
-        )
-
-    def serialize(self) -> dict:
-        serialized = {
-            "id": self.passenger_id,
-            "status": convert_passenger_status_to_string(self.status),
-            "numberOfPassengers": self.number_of_passengers,
-        }
-
-        if self.name is not None:
-            serialized["name"] = self.name
-
-        serialized["previousLegs"] = [leg.serialize() for leg in self.previous_legs]
-
-        if self.current_leg is not None:
-            serialized["currentLeg"] = self.current_leg.serialize()
-
-        serialized["nextLegs"] = [leg.serialize() for leg in self.next_legs]
-
-        return serialized
-
-    @staticmethod
-    def deserialize(data: str) -> "VisualizedPassenger":
-        if isinstance(data, str):
-            data = json.loads(data.replace("'", '"'))
-
-        if (
-            "id" not in data
-            or "status" not in data
-            or "previousLegs" not in data
-            or "nextLegs" not in data
-            or "numberOfPassengers" not in data
-        ):
-            raise ValueError("Invalid data for VisualizedPassenger")
-
-        passenger_id = str(data["id"])
-        name = data.get("name", None)
-        status = convert_string_to_passenger_status(data["status"])
-        number_of_passengers = int(data["numberOfPassengers"])
-
-        previous_legs = [
-            VisualizedLeg.deserialize(leg_data) for leg_data in data["previousLegs"]
-        ]
-        next_legs = [
-            VisualizedLeg.deserialize(leg_data) for leg_data in data["nextLegs"]
-        ]
-
-        current_leg = data.get("currentLeg", None)
-        if current_leg is not None:
-            current_leg = VisualizedLeg.deserialize(current_leg)
-
-        return VisualizedPassenger(
-            passenger_id,
-            name,
-            status,
-            number_of_passengers,
-            previous_legs,
-            current_leg,
-            next_legs,
-        )
-
-
-# MARK: Stop
-class VisualizedStop(Serializable):
-    arrival_time: float
-    departure_time: float | None
-    latitude: float | None
-    longitude: float | None
-    capacity: int | None
-    label: str
-
-    def __init__(
-        self,
-        arrival_time: float,
-        departure_time: float,
-        latitude: float | None,
-        longitude: float | None,
-        capacity: int | None,
-        label: str,
-    ) -> None:
-        self.arrival_time = arrival_time
-        self.departure_time = departure_time
-        self.latitude = latitude
-        self.longitude = longitude
-        self.capacity = capacity
-        self.label = label
-
-    @classmethod
-    def from_stop(cls, stop: Stop) -> "VisualizedStop":
-        return cls(
-            stop.arrival_time,
-            stop.departure_time if stop.departure_time != math.inf else None,
-            stop.location.lat,
-            stop.location.lon,
-            stop.capacity,
-            stop.location.label,
-        )
-
-    def serialize(self) -> dict:
-        serialized = {"arrivalTime": self.arrival_time}
-
-        if self.departure_time is not None:
-            serialized["departureTime"] = self.departure_time
-
-        if self.latitude is not None and self.longitude is not None:
-            serialized["position"] = {
-                "latitude": self.latitude,
-                "longitude": self.longitude,
-            }
-
-        if self.capacity is not None:
-            serialized["capacity"] = self.capacity
-
-        serialized["label"] = self.label
-
-        return serialized
-
-    @staticmethod
-    def deserialize(data: str) -> "VisualizedStop":
-        if isinstance(data, str):
-            data = json.loads(data.replace("'", '"'))
-
-        if "arrivalTime" not in data or "label" not in data:
-            raise ValueError("Invalid data for VisualizedStop")
-
-        arrival_time = float(data["arrivalTime"])
-        departure_time = data.get("departureTime", None)
-
-        latitude = None
-        longitude = None
-
-        position = data.get("position", None)
-
-        if position is not None:
-            latitude = position.get("latitude", None)
-            longitude = position.get("longitude", None)
-
-        capacity = data.get("capacity", None)
-
-        if capacity is not None:
-            capacity = int(capacity)
-
-            label = data["label"]
-
-        return VisualizedStop(
-            arrival_time, departure_time, latitude, longitude, capacity, label
-        )
-
-
-# MARK: Vehicle
-class VisualizedVehicle(Serializable):
-    vehicle_id: str
-    mode: str | None
-    status: VehicleStatus
-    polylines: dict[str, tuple[str, list[float]]] | None
-    previous_stops: list[VisualizedStop]
-    current_stop: VisualizedStop | None
-    next_stops: list[VisualizedStop]
-    capacity: int
-    name: str | None
-
-    def __init__(
-        self,
-        vehicle_id: str | int,
-        mode: str | None,
-        status: VehicleStatus,
-        polylines: dict[str, tuple[str, list[float]]] | None,
-        previous_stops: list[VisualizedStop],
-        current_stop: VisualizedStop | None,
-        next_stops: list[VisualizedStop],
-        capacity: int,
-        name: str | None = None,
-    ) -> None:
-        self.vehicle_id = str(vehicle_id)
-        self.mode = mode
-        self.status = status
-        self.polylines = polylines
-
-        self.previous_stops = previous_stops
-        self.current_stop = current_stop
-        self.next_stops = next_stops
-
-        self.capacity = capacity
-        self.name = name
-
-    @property
-    def all_stops(self) -> list[VisualizedStop]:
-        return (
-            self.previous_stops
-            + ([self.current_stop] if self.current_stop is not None else [])
-            + self.next_stops
-        )
-
-    @classmethod
-    def from_vehicle_and_route(
-        cls, vehicle: Vehicle, route: Route
-    ) -> "VisualizedVehicle":
-        previous_stops = [
-            VisualizedStop.from_stop(stop) for stop in route.previous_stops
-        ]
-        current_stop = (
-            VisualizedStop.from_stop(route.current_stop)
-            if route.current_stop is not None
-            else None
-        )
-        next_stops = [VisualizedStop.from_stop(stop) for stop in route.next_stops]
-        return cls(
-            vehicle.id,
-            vehicle.mode,
-            vehicle.status,
-            vehicle.polylines,
-            previous_stops,
-            current_stop,
-            next_stops,
-            vehicle.capacity,
-            vehicle.name,
-        )
-
-    def serialize(self) -> dict:
-        serialized = {
-            "id": self.vehicle_id,
-            "status": convert_vehicle_status_to_string(self.status),
-            "previousStops": [stop.serialize() for stop in self.previous_stops],
-            "nextStops": [stop.serialize() for stop in self.next_stops],
-            "capacity": self.capacity,
-            "name": self.name,
-        }
-
-        if self.mode is not None:
-            serialized["mode"] = self.mode
-
-        if self.current_stop is not None:
-            serialized["currentStop"] = self.current_stop.serialize()
-
-        return serialized
-
-    @staticmethod
-    def deserialize(data: str | dict) -> "VisualizedVehicle":
-        if isinstance(data, str):
-            data = json.loads(data.replace("'", '"'))
-
-        if (
-            "id" not in data
-            or "status" not in data
-            or "previousStops" not in data
-            or "nextStops" not in data
-            or "capacity" not in data
-            or "name" not in data
-        ):
-            raise ValueError("Invalid data for VisualizedVehicle")
-
-        vehicle_id = str(data["id"])
-        mode = data.get("mode", None)
-        status = convert_string_to_vehicle_status(data["status"])
-        previous_stops = [
-            VisualizedStop.deserialize(stop_data) for stop_data in data["previousStops"]
-        ]
-        next_stops = [
-            VisualizedStop.deserialize(stop_data) for stop_data in data["nextStops"]
-        ]
-        capacity = int(data["capacity"])
-        name = data.get("name", None)
-
-        current_stop = data.get("currentStop", None)
-        if current_stop is not None:
-            current_stop = VisualizedStop.deserialize(current_stop)
-
-        return VisualizedVehicle(
-            vehicle_id,
-            mode,
-            status,
-            None,
-            previous_stops,
-            current_stop,
-            next_stops,
-            capacity,
-            name,
-        )
-
-
-# MARK: Environment
-class VisualizedEnvironment(Serializable):
-    passengers: dict[str, VisualizedPassenger]
-    vehicles: dict[str, VisualizedVehicle]
-    statistic: dict[str, dict[str, dict[str, int]]]
-    timestamp: float
-    estimated_end_time: float
-    order: int
-
-    def __init__(self) -> None:
-        self.passengers = {}
-        self.vehicles = {}
-        self.timestamp = 0
-        self.estimated_end_time = 0
-        self.order = 0
-        self.statistic = None
-
-    def add_passenger(self, passenger: VisualizedPassenger) -> None:
-        self.passengers[passenger.passenger_id] = passenger
-
-    def get_passenger(self, passenger_id: str) -> VisualizedPassenger:
-        if passenger_id in self.passengers:
-            return self.passengers[passenger_id]
-        raise ValueError(f"Passenger {passenger_id} not found")
-
-    def add_vehicle(self, vehicle: VisualizedVehicle) -> None:
-        self.vehicles[vehicle.vehicle_id] = vehicle
-
-    def get_vehicle(self, vehicle_id: str) -> VisualizedVehicle:
-        if vehicle_id in self.vehicles:
-            return self.vehicles[vehicle_id]
-        raise ValueError(f"Vehicle {vehicle_id} not found")
-
-    def serialize(self) -> dict:
-        return {
-            "passengers": [
-                passenger.serialize() for passenger in self.passengers.values()
-            ],
-            "vehicles": [vehicle.serialize() for vehicle in self.vehicles.values()],
-            "timestamp": self.timestamp,
-            "estimatedEndTime": self.estimated_end_time,
-            "statistic": self.statistic if self.statistic is not None else {},
-            "order": self.order,
-        }
-
-    @staticmethod
-    def deserialize(data: str) -> "VisualizedEnvironment":
-        if isinstance(data, str):
-            data = json.loads(data.replace("'", '"'))
-
-        if (
-            "passengers" not in data
-            or "vehicles" not in data
-            or "timestamp" not in data
-            or "estimatedEndTime" not in data
-            or "statistic" not in data
-            or "order" not in data
-        ):
-            raise ValueError("Invalid data for VisualizedEnvironment")
-
-        environment = VisualizedEnvironment()
-        for passenger_data in data["passengers"]:
-            passenger = VisualizedPassenger.deserialize(passenger_data)
-            environment.add_passenger(passenger)
-
-        for vehicle_data in data["vehicles"]:
-            vehicle = VisualizedVehicle.deserialize(vehicle_data)
-            environment.add_vehicle(vehicle)
-
-        environment.timestamp = data["timestamp"]
-        environment.estimated_end_time = data["estimatedEndTime"]
-        environment.statistic = data["statistic"]
-        environment.order = data["order"]
-
-        return environment
-
-
-# MARK: Updates
-class UpdateType(Enum):
-    CREATE_PASSENGER = "createPassenger"
-    CREATE_VEHICLE = "createVehicle"
-    UPDATE_PASSENGER_STATUS = "updatePassengerStatus"
-    UPDATE_PASSENGER_LEGS = "updatePassengerLegs"
-    UPDATE_VEHICLE_STATUS = "updateVehicleStatus"
-    UPDATE_VEHICLE_STOPS = "updateVehicleStops"
-    UPDATE_STATISTIC = "updateStatistic"
-
-
-class StatisticUpdate(Serializable):
-    statistic: dict[str, dict[str, dict[str, int]]]
-
-    def __init__(self, statistic: dict) -> None:
-        self.statistic = statistic
-
-    def serialize(self) -> dict[str, dict[str, dict[str, int]]]:
-        return {"statistic": self.statistic}
-
-    @staticmethod
-    def deserialize(data: str) -> "StatisticUpdate":
-        if isinstance(data, str):
-            data = json.loads(data.replace("'", '"'))
-
-        if "statistic" not in data:
-            raise ValueError("Invalid data for StatisticUpdate")
-
-        return StatisticUpdate(data.statistic)
-
-
-class PassengerStatusUpdate(Serializable):
-    passenger_id: str
-    status: PassengerStatus
-
-    def __init__(self, passenger_id: str, status: PassengerStatus) -> None:
-        self.passenger_id = passenger_id
-        self.status = status
-
-    def from_trip(trip: Trip) -> "PassengerStatusUpdate":
-        return PassengerStatusUpdate(trip.id, trip.status)
-
-    def serialize(self) -> dict:
-        return {
-            "id": self.passenger_id,
-            "status": convert_passenger_status_to_string(self.status),
-        }
-
-    @staticmethod
-    def deserialize(data: str) -> "PassengerStatusUpdate":
-        if isinstance(data, str):
-            data = json.loads(data.replace("'", '"'))
-
-        if "id" not in data or "status" not in data:
-            raise ValueError("Invalid data for PassengerStatusUpdate")
-
-        passenger_id = str(data["id"])
-        status = convert_string_to_passenger_status(data["status"])
-        return PassengerStatusUpdate(passenger_id, status)
-
-
-class PassengerLegsUpdate(Serializable):
-    passenger_id: str
-    previous_legs: list[VisualizedLeg]
-    current_leg: VisualizedLeg | None
-    next_legs: list[VisualizedLeg]
-
-    def __init__(
-        self,
-        passenger_id: str,
-        previous_legs: list[VisualizedLeg],
-        current_leg: VisualizedLeg | None,
-        next_legs: list[VisualizedLeg],
-    ) -> None:
-        self.passenger_id = passenger_id
-        self.previous_legs = previous_legs
-        self.current_leg = current_leg
-        self.next_legs = next_legs
-
-    @classmethod
-    def from_trip_environment_and_previous_passenger(
-        cls,
-        trip: Trip,
-        environment: Environment,
-        previous_passenger: VisualizedPassenger,
-    ) -> "PassengerLegsUpdate":
-        all_previous_legs = (
-            previous_passenger.previous_legs
-            + (
-                [previous_passenger.current_leg]
-                if previous_passenger.current_leg is not None
-                else []
-            )
-            + previous_passenger.next_legs
-        )
-        current_index = 0
-
-        previous_legs = []
-        for leg in trip.previous_legs:
-            previous_leg = None
-            if current_index < len(all_previous_legs):
-                previous_leg = all_previous_legs[current_index]
-                current_index += 1
-            previous_legs.append(
-                VisualizedLeg.from_leg_environment_and_trip(
-                    leg, environment, trip, previous_leg
-                )
-            )
-
-        previous_leg = None
-        if trip.current_leg is not None and current_index < len(all_previous_legs):
-            previous_leg = all_previous_legs[current_index]
-            current_index += 1
-        current_leg = (
-            VisualizedLeg.from_leg_environment_and_trip(
-                trip.current_leg, environment, trip, previous_leg
-            )
-            if trip.current_leg is not None
-            else None
-        )
-
-        next_legs = []
-        for leg in trip.next_legs:
-            next_leg = None
-            if current_index < len(all_previous_legs):
-                next_leg = all_previous_legs[current_index]
-                current_index += 1
-            next_legs.append(
-                VisualizedLeg.from_leg_environment_and_trip(
-                    leg, environment, trip, next_leg
-                )
-            )
-
-        return cls(trip.id, previous_legs, current_leg, next_legs)
-
-    def serialize(self) -> dict:
-        serialized = {
-            "id": self.passenger_id,
-            "previousLegs": [leg.serialize() for leg in self.previous_legs],
-            "nextLegs": [leg.serialize() for leg in self.next_legs],
-        }
-
-        if self.current_leg is not None:
-            serialized["currentLeg"] = self.current_leg.serialize()
-
-        return serialized
-
-    @staticmethod
-    def deserialize(data: str) -> "PassengerLegsUpdate":
-        if isinstance(data, str):
-            data = json.loads(data.replace("'", '"'))
-
-        if "id" not in data or "previousLegs" not in data or "nextLegs" not in data:
-            raise ValueError("Invalid data for PassengerLegsUpdate")
-
-        passenger_id = str(data["id"])
-        previous_legs = [
-            VisualizedLeg.deserialize(leg_data) for leg_data in data["previousLegs"]
-        ]
-        next_legs = [
-            VisualizedLeg.deserialize(leg_data) for leg_data in data["nextLegs"]
-        ]
-
-        current_leg = data.get("currentLeg", None)
-        if current_leg is not None:
-            current_leg = VisualizedLeg.deserialize(current_leg)
-
-        return PassengerLegsUpdate(passenger_id, previous_legs, current_leg, next_legs)
-
-
-class VehicleStatusUpdate(Serializable):
-    vehicle_id: str
-    status: VehicleStatus
-
-    def __init__(self, vehicle_id: str, status: VehicleStatus) -> None:
-        self.vehicle_id = vehicle_id
-        self.status = status
-
-    def from_vehicle(vehicle: Vehicle) -> "VehicleStatusUpdate":
-        return VehicleStatusUpdate(vehicle.id, vehicle.status)
-
-    def serialize(self) -> dict:
-        return {
-            "id": self.vehicle_id,
-            "status": convert_vehicle_status_to_string(self.status),
-        }
-
-    @staticmethod
-    def deserialize(data: str) -> "VehicleStatusUpdate":
-        if isinstance(data, str):
-            data = json.loads(data.replace("'", '"'))
-
-        if "id" not in data or "status" not in data:
-            raise ValueError("Invalid data for VehicleStatusUpdate")
-
-        vehicle_id = str(data["id"])
-        status = convert_string_to_vehicle_status(data["status"])
-        return VehicleStatusUpdate(vehicle_id, status)
-
-
-class VehicleStopsUpdate(Serializable):
-    vehicle_id: str
-    previous_stops: list[VisualizedStop]
-    current_stop: VisualizedStop | None
-    next_stops: list[VisualizedStop]
-
-    def __init__(
-        self,
-        vehicle_id: str,
-        previous_stops: list[VisualizedStop],
-        current_stop: VisualizedStop | None,
-        next_stops: list[VisualizedStop],
-    ) -> None:
-        self.vehicle_id = vehicle_id
-        self.previous_stops = previous_stops
-        self.current_stop = current_stop
-        self.next_stops = next_stops
-
-    @classmethod
-    def from_vehicle_and_route(
-        cls, vehicle: Vehicle, route: Route
-    ) -> "VehicleStopsUpdate":
-        previous_stops = [
-            VisualizedStop.from_stop(stop) for stop in route.previous_stops
-        ]
-        current_stop = (
-            VisualizedStop.from_stop(route.current_stop)
-            if route.current_stop is not None
-            else None
-        )
-        next_stops = [VisualizedStop.from_stop(stop) for stop in route.next_stops]
-        return cls(vehicle.id, previous_stops, current_stop, next_stops)
-
-    def serialize(self) -> dict:
-        serialized = {
-            "id": self.vehicle_id,
-            "previousStops": [stop.serialize() for stop in self.previous_stops],
-            "nextStops": [stop.serialize() for stop in self.next_stops],
-        }
-
-        if self.current_stop is not None:
-            serialized["currentStop"] = self.current_stop.serialize()
-
-        return serialized
-
-    @staticmethod
-    def deserialize(data: str) -> "VehicleStopsUpdate":
-        if isinstance(data, str):
-            data = json.loads(data.replace("'", '"'))
-
-        if "id" not in data or "previousStops" not in data or "nextStops" not in data:
-            raise ValueError("Invalid data for VehicleStopsUpdate")
-
-        vehicle_id = str(data["id"])
-        previous_stops = [
-            VisualizedStop.deserialize(stop_data) for stop_data in data["previousStops"]
-        ]
-        next_stops = [
-            VisualizedStop.deserialize(stop_data) for stop_data in data["nextStops"]
-        ]
-
-        current_stop = data.get("currentStop", None)
-        if current_stop is not None:
-            current_stop = VisualizedStop.deserialize(current_stop)
-
-        return VehicleStopsUpdate(vehicle_id, previous_stops, current_stop, next_stops)
-
-
-class Update(Serializable):
-    type: UpdateType
-    data: Serializable
-    timestamp: float
-    order: int
-
-    def __init__(
-        self,
-        type: UpdateType,
-        data: Serializable,
-        timestamp: float,
-    ) -> None:
-        self.type = type
-        self.data = data
-        self.timestamp = timestamp
-        self.order = 0
-
-    def serialize(self) -> dict:
-        return {
-            "type": self.type.value,
-            "data": self.data.serialize(),
-            "timestamp": self.timestamp,
-            "order": self.order,
-        }
-
-    @staticmethod
-    def deserialize(data: str) -> "Update":
-        if isinstance(data, str):
-            data = json.loads(data.replace("'", '"'))
-
-        if (
-            "type" not in data
-            or "data" not in data
-            or "timestamp" not in data
-            or "order" not in data
-        ):
-            raise ValueError("Invalid data for Update")
-
-        update_type = UpdateType(data["type"])
-        update_data = data["data"]
-        timestamp = float(data["timestamp"])
-
-        if update_type == UpdateType.CREATE_PASSENGER:
-            update_data = VisualizedPassenger.deserialize(update_data)
-        elif update_type == UpdateType.CREATE_VEHICLE:
-            update_data = VisualizedVehicle.deserialize(update_data)
-        elif update_type == UpdateType.UPDATE_PASSENGER_STATUS:
-            update_data = PassengerStatusUpdate.deserialize(update_data)
-        elif update_type == UpdateType.UPDATE_PASSENGER_LEGS:
-            update_data = PassengerLegsUpdate.deserialize(update_data)
-        elif update_type == UpdateType.UPDATE_VEHICLE_STATUS:
-            update_data = VehicleStatusUpdate.deserialize(update_data)
-        elif update_type == UpdateType.UPDATE_VEHICLE_STOPS:
-            update_data = VehicleStopsUpdate.deserialize(update_data)
-        elif update_type == UpdateType.UPDATE_STATISTIC:
-            update_data = StatisticUpdate.deserialize(update_data)
-
-        update = Update(update_type, update_data, timestamp)
-        update.order = data["order"]
-        return update
-
-
-# MARK: State
-class VisualizedState(VisualizedEnvironment):
-    updates: list[Update]
-
-    def __init__(self) -> None:
-        super().__init__()
-        self.updates = []
-
-    @classmethod
-    def from_environment(cls, environment: VisualizedEnvironment) -> "VisualizedState":
-        state = cls()
-        state.passengers = environment.passengers
-        state.vehicles = environment.vehicles
-        state.timestamp = environment.timestamp
-        state.estimated_end_time = environment.estimated_end_time
-        state.order = environment.order
-        return state
-
-    def serialize(self) -> dict:
-        serialized = super().serialize()
-        serialized["updates"] = [update.serialize() for update in self.updates]
-        return serialized
-
-    @staticmethod
-    def deserialize(data: str) -> "VisualizedState":
-        if isinstance(data, str):
-            data = json.loads(data.replace("'", '"'))
-
-        if "updates" not in data:
-            raise ValueError("Invalid data for VisualizedState")
-
-        environment = VisualizedEnvironment.deserialize(data)
-
-        state = VisualizedState()
-        state.passengers = environment.passengers
-        state.vehicles = environment.vehicles
-        state.timestamp = environment.timestamp
-        state.estimated_end_time = environment.estimated_end_time
-        state.order = environment.order
-
-        for update_data in data["updates"]:
-            update = Update.deserialize(update_data)
-            state.updates.append(update)
-
-        return state
-
-
-# MARK: Simulation Information
-class SimulationInformation(Serializable):
-    version: int
-    simulation_id: str
-    name: str
-    start_time: str
-    data: str
-    simulation_start_time: float | None
-    simulation_end_time: float | None
-    last_update_order: int | None
-
-    def __init__(
-        self,
-        simulation_id: str,
-        data: str,
-        simulation_start_time: str | None,
-        simulation_end_time: str | None,
-        last_update_order: int | None,
-        version: int | None,
-    ) -> None:
-        self.version = version
-        if self.version is None:
-            self.version = SAVE_VERSION
-
-        self.simulation_id = simulation_id
-
-        self.name = simulation_id.split(SIMULATION_SAVE_FILE_SEPARATOR)[1]
-        self.start_time = simulation_id.split(SIMULATION_SAVE_FILE_SEPARATOR)[0]
-        self.data = data
-
-        self.simulation_start_time = simulation_start_time
-        self.simulation_end_time = simulation_end_time
-        self.last_update_order = last_update_order
-
-    def serialize(self) -> dict:
-        serialized = {
-            "version": self.version,
-            "simulationId": self.simulation_id,
-            "name": self.name,
-            "startTime": self.start_time,
-            "data": self.data,
-        }
-        if self.simulation_start_time is not None:
-            serialized["simulationStartTime"] = self.simulation_start_time
-        if self.simulation_end_time is not None:
-            serialized["simulationEndTime"] = self.simulation_end_time
-        if self.last_update_order is not None:
-            serialized["lastUpdateOrder"] = self.last_update_order
-        return serialized
-
-    @staticmethod
-    def deserialize(data: str) -> "SimulationInformation":
-        if isinstance(data, str):
-            data = json.loads(data.replace("'", '"'))
-
-        if "version" not in data or "simulationId" not in data:
-            raise ValueError("Invalid data for SimulationInformation")
-
-        version = int(data["version"])
-        simulation_id = str(data["simulationId"])
-        simulation_data = str(data["data"])
-
-        simulation_start_time = data.get("simulationStartTime", None)
-        simulation_end_time = data.get("simulationEndTime", None)
-        last_update_order = data.get("lastUpdateOrder", None)
-
-        return SimulationInformation(
-            simulation_id,
-            simulation_data,
-            simulation_start_time,
-            simulation_end_time,
-            last_update_order,
-            version,
-        )
-
-
-# TODO Send it to client
-# def get_size(start_path: str) -> int:
-#     total_size = 0
-#     for directory_path, _, file_names in os.walk(start_path):
-#         for file_name in file_names:
-#             file_path = os.path.join(directory_path, file_name)
-#             total_size += os.path.getsize(file_path)
-#     return total_size
-
-
-# MARK: SVDM
-class SimulationVisualizationDataManager:
-    """
-    This class manage reads and writes of simulation data for visualization.
-    """
-
-    __CORRUPTED_FILE_NAME = ".corrupted"
-    __SAVED_SIMULATIONS_DIRECTORY_NAME = "saved_simulations"
-    __SIMULATION_INFORMATION_FILE_NAME = "simulation_information.json"
-    __STATES_DIRECTORY_NAME = "states"
-    __POLYLINES_DIRECTORY_NAME = "polylines"
-    __POLYLINES_FILE_NAME = "polylines"
-    __POLYLINES_VERSION_FILE_NAME = "version"
-
-    __STATES_ORDER_MINIMUM_LENGTH = 8
-    __STATES_TIMESTAMP_MINIMUM_LENGTH = 8
-
-    # Only send a maximum of __MAX_STATES_AT_ONCE states at once
-    # This should be at least 2
-    __MAX_STATES_AT_ONCE = 2
-
-    # The client keeps a maximum of __MAX_STATES_IN_CLIENT_BEFORE_NECESSARY + __MAX_STATES_IN_CLIENT_AFTER_NECESSARY + 1
-    # states in memory
-    # The current one, the previous __MAX_STATES_IN_CLIENT_BEFORE_NECESSARY and the next __MAX_STATES_IN_CLIENT_AFTER_NECESSARY
-    # __MAX_STATES_IN_CLIENT_BEFORE_NECESSARY = 24
-    # __MAX_STATES_IN_CLIENT_AFTER_NECESSARY = 50
-
-    # MARK: +- Format
-    @staticmethod
-    def __format_json_readable(data: dict, file: str) -> str:
-        return json.dump(data, file, indent=2, separators=(",", ": "), sort_keys=True)
-
-    @staticmethod
-    def __format_json_one_line(data: dict, file: str) -> str:
-        # Add new line before if not empty
-        if file.tell() != 0:
-            file.write("\n")
-        return json.dump(data, file, separators=(",", ":"))
-
-    # MARK: +- File paths
-    @staticmethod
-    def get_saved_simulations_directory_path() -> str:
-        current_directory = os.path.dirname(os.path.abspath(__file__))
-        directory_path = f"{current_directory}/{SimulationVisualizationDataManager.__SAVED_SIMULATIONS_DIRECTORY_NAME}"
-
-        if not os.path.exists(directory_path):
-            os.makedirs(directory_path)
-
-        return directory_path
-
-    @staticmethod
-    def get_all_saved_simulation_ids() -> list[str]:
-        directory_path = (
-            SimulationVisualizationDataManager.get_saved_simulations_directory_path()
-        )
-        return [simulation_id for simulation_id in os.listdir(directory_path)]
-
-    @staticmethod
-    def get_saved_simulation_directory_path(simulation_id: str) -> str:
-        directory_path = (
-            SimulationVisualizationDataManager.get_saved_simulations_directory_path()
-        )
-        simulation_directory_path = f"{directory_path}/{simulation_id}"
-
-        if not os.path.exists(simulation_directory_path):
-            os.makedirs(simulation_directory_path)
-
-        return simulation_directory_path
-
-    # MARK: +- Corrupted
-    @staticmethod
-    def is_simulation_corrupted(simulation_id: str) -> bool:
-        simulation_directory_path = (
-            SimulationVisualizationDataManager.get_saved_simulation_directory_path(
-                simulation_id
-            )
-        )
-
-        return os.path.exists(
-            f"{simulation_directory_path}/{SimulationVisualizationDataManager.__CORRUPTED_FILE_NAME}"
-        )
-
-    @staticmethod
-    def mark_simulation_as_corrupted(simulation_id: str) -> None:
-        simulation_directory_path = (
-            SimulationVisualizationDataManager.get_saved_simulation_directory_path(
-                simulation_id
-            )
-        )
-
-        file_path = f"{simulation_directory_path}/{SimulationVisualizationDataManager.__CORRUPTED_FILE_NAME}"
-
-        with open(file_path, "w") as file:
-            file.write("")
-
-    # MARK: +- Simulation Information
-    @staticmethod
-    def get_saved_simulation_information_file_path(simulation_id: str) -> str:
-        simulation_directory_path = (
-            SimulationVisualizationDataManager.get_saved_simulation_directory_path(
-                simulation_id
-            )
-        )
-        file_path = f"{simulation_directory_path}/{SimulationVisualizationDataManager.__SIMULATION_INFORMATION_FILE_NAME}"
-
-        if not os.path.exists(file_path):
-            with open(file_path, "w") as file:
-                file.write("")
-
-        return file_path
-
-    @staticmethod
-    def set_simulation_information(
-        simulation_id: str, simulation_information: SimulationInformation
-    ) -> None:
-        file_path = SimulationVisualizationDataManager.get_saved_simulation_information_file_path(
-            simulation_id
-        )
-
-        lock = FileLock(f"{file_path}.lock")
-
-        with lock:
-            with open(file_path, "w") as file:
-                SimulationVisualizationDataManager.__format_json_readable(
-                    simulation_information.serialize(), file
-                )
-
-    @staticmethod
-    def get_simulation_information(simulation_id: str) -> SimulationInformation:
-        file_path = SimulationVisualizationDataManager.get_saved_simulation_information_file_path(
-            simulation_id
-        )
-
-        lock = FileLock(f"{file_path}.lock")
-
-        with lock:
-            with open(file_path, "r") as file:
-                data = file.read()
-                return SimulationInformation.deserialize(data)
-
-    # MARK: +- States and updates
-    @staticmethod
-    def get_saved_simulation_states_folder_path(simulation_id: str) -> str:
-        simulation_directory_path = (
-            SimulationVisualizationDataManager.get_saved_simulation_directory_path(
-                simulation_id
-            )
-        )
-        folder_path = f"{simulation_directory_path}/{SimulationVisualizationDataManager.__STATES_DIRECTORY_NAME}"
-
-        if not os.path.exists(folder_path):
-            os.makedirs(folder_path)
-
-        return folder_path
-
-    @staticmethod
-    def get_saved_simulation_state_file_path(
-        simulation_id: str, order: int, timestamp: float
-    ) -> str:
-        folder_path = (
-            SimulationVisualizationDataManager.get_saved_simulation_states_folder_path(
-                simulation_id
-            )
-        )
-
-        padded_order = str(order).zfill(
-            SimulationVisualizationDataManager.__STATES_ORDER_MINIMUM_LENGTH
-        )
-        padded_timestamp = str(int(timestamp)).zfill(
-            SimulationVisualizationDataManager.__STATES_TIMESTAMP_MINIMUM_LENGTH
-        )
-
-        # States and updates are stored in a .jsonl file to speed up reads and writes
-        # Each line is a state (the first line) or an update (the following lines)
-        file_path = f"{folder_path}/{padded_order}-{padded_timestamp}.jsonl"
-
-        if not os.path.exists(file_path):
-            with open(file_path, "w") as file:
-                file.write("")
-
-        return file_path
-
-    @staticmethod
-    def get_sorted_states(simulation_id: str) -> list[tuple[int, float]]:
-        folder_path = (
-            SimulationVisualizationDataManager.get_saved_simulation_states_folder_path(
-                simulation_id
-            )
-        )
-
-        all_states_files = [
-            path for path in os.listdir(folder_path) if path.endswith(".jsonl")
-        ]  # Filter out lock files
-
-        states = []
-        for state_file in all_states_files:
-            order, timestamp = state_file.split("-")
-            states.append((int(order), float(timestamp.split(".")[0])))
-
-        return sorted(states, key=lambda x: (x[1], x[0]))
-
-    @staticmethod
-    def save_state(simulation_id: str, environment: VisualizedEnvironment) -> str:
-        file_path = (
-            SimulationVisualizationDataManager.get_saved_simulation_state_file_path(
-                simulation_id, environment.order, environment.timestamp
-            )
-        )
-
-        lock = FileLock(f"{file_path}.lock")
-
-        with lock:
-            with open(file_path, "w") as file:
-                SimulationVisualizationDataManager.__format_json_one_line(
-                    environment.serialize(), file
-                )
-
-        return file_path
-
-    @staticmethod
-    def save_update(file_path: str, update: Update) -> None:
-        lock = FileLock(f"{file_path}.lock")
-        with lock:
-            with open(file_path, "a") as file:
-                SimulationVisualizationDataManager.__format_json_one_line(
-                    update.serialize(), file
-                )
-
-    @staticmethod
-    def get_missing_states(
-        simulation_id: str,
-        visualization_time: float,
-        loaded_state_orders: list[int],
-        is_simulation_complete: bool,
-    ) -> tuple[list[str], dict[list[str]], list[int], bool, int, int, int]:
-        sorted_states = SimulationVisualizationDataManager.get_sorted_states(
-            simulation_id
-        )
-
-        if len(sorted_states) == 0:
-            return ([], {}, [], False, 0, 0, 0)
-
-        necessary_state_index = None
-
-        for index, (order, state_timestamp) in enumerate(sorted_states):
-            if necessary_state_index is None and state_timestamp > visualization_time:
-                necessary_state_index = index
-                break
-
-        if necessary_state_index is None:
-            # If the visualization time is after the last state then
-            # The last state is necessary
-            necessary_state_index = len(sorted_states) - 1
-        else:
-            # Else we need the state before the first state with greater timestamp
-            necessary_state_index -= 1
-
-        # Handle negative indexes
-        necessary_state_index = max(0, necessary_state_index)
-
-        state_orders_to_keep = []
-        missing_states = []
-        missing_updates = {}
-
-        last_state_index_in_client = -1
-        all_state_indexes_in_client = []
-
-        # We want to load the necessary state first, followed by
-        # the __MAX_STATES_IN_CLIENT_AFTER_NECESSARY next states and
-        # then the __MAX_STATES_IN_CLIENT_BEFORE_NECESSARY previous states
-        indexes_to_load = (
-            [necessary_state_index]
-            # + [
-            #     next_state_index
-            #     for next_state_index in range(
-            #         necessary_state_index + 1,
-            #         min(
-            #             necessary_state_index
-            #             + SimulationVisualizationDataManager.__MAX_STATES_IN_CLIENT_AFTER_NECESSARY
-            #             + 1,
-            #             len(sorted_states),
-            #         ),
-            #     )
-            # ]
-            # + [
-            #     previous_state_index
-            #     for previous_state_index in range(
-            #         necessary_state_index - 1,
-            #         max(
-            #             necessary_state_index
-            #             - SimulationVisualizationDataManager.__MAX_STATES_IN_CLIENT_BEFORE_NECESSARY
-            #             - 1,
-            #             -1,
-            #         ),
-            #         -1,
-            #     )
-            # ]
-            # All next states
-            + [
-                next_state_index
-                for next_state_index in range(
-                    necessary_state_index + 1, len(sorted_states)
-                )
-            ]
-            # All previous states
-            + [
-                previous_state_index
-                for previous_state_index in range(necessary_state_index - 1, -1, -1)
-            ]
-        )
-
-        for index in indexes_to_load:
-            order, state_timestamp = sorted_states[index]
-
-            # If the client already has the state, skip it
-            # except the last state that might have changed
-            if order in loaded_state_orders and not order == max(loaded_state_orders):
-                state_orders_to_keep.append(order)
-
-                all_state_indexes_in_client.append(index)
-                if index > last_state_index_in_client:
-                    last_state_index_in_client = index
-
-                continue
-
-            # Don't add states if the max number of states is reached
-            # but continue the loop to know which states need to be kept
-            if (
-                len(missing_states)
-                >= SimulationVisualizationDataManager.__MAX_STATES_AT_ONCE
-            ):
-                continue
-
-            state_file_path = (
-                SimulationVisualizationDataManager.get_saved_simulation_state_file_path(
-                    simulation_id, order, state_timestamp
-                )
-            )
-
-            lock = FileLock(f"{state_file_path}.lock")
-
-            with lock:
-                with open(state_file_path, "r") as file:
-                    environment_data = file.readline()
-                    missing_states.append(environment_data)
-
-                    updates_data = file.readlines()
-                    current_state_updates = []
-                    for update_data in updates_data:
-                        current_state_updates.append(update_data)
-
-                    missing_updates[order] = current_state_updates
-
-                    all_state_indexes_in_client.append(index)
-                    if index > last_state_index_in_client:
-                        last_state_index_in_client = index
-
-        client_has_last_state = last_state_index_in_client == len(sorted_states) - 1
-        client_has_max_states = len(missing_states) + len(state_orders_to_keep) >= len(
-            indexes_to_load
-        )
-
-        should_request_more_states = (
-            is_simulation_complete and not client_has_max_states
-        ) or (
-            not is_simulation_complete
-            and (client_has_last_state or not client_has_max_states)
-        )
-
-        first_continuous_state_index = necessary_state_index
-        last_continuous_state_index = necessary_state_index
-
-        all_state_indexes_in_client.sort()
-
-        necessary_state_index_index = all_state_indexes_in_client.index(
-            necessary_state_index
-        )
-
-        for index in range(necessary_state_index_index - 1, -1, -1):
-            if all_state_indexes_in_client[index] == first_continuous_state_index - 1:
-                first_continuous_state_index -= 1
-            else:
-                break
-
-        for index in range(
-            necessary_state_index_index + 1, len(all_state_indexes_in_client)
-        ):
-            if all_state_indexes_in_client[index] == last_continuous_state_index + 1:
-                last_continuous_state_index += 1
-            else:
-                break
-
-        first_continuous_state_order = sorted_states[first_continuous_state_index][0]
-        last_continuous_state_order = sorted_states[last_continuous_state_index][0]
-
-        necessary_state_order = sorted_states[necessary_state_index][0]
-
-        return (
-            missing_states,
-            missing_updates,
-            state_orders_to_keep,
-            should_request_more_states,
-            first_continuous_state_order,
-            last_continuous_state_order,
-            necessary_state_order,
-        )
-
-    # MARK: +- Polylines
-
-    # The polylines are saved with the following structure :
-    # polylines/
-    #   version
-    #   polylines.jsonl
-    #     { "coordinatesString": "string", "encodedPolyline": "string", "coefficients": [float] }
-
-    @staticmethod
-    def get_saved_simulation_polylines_lock(simulation_id: str) -> FileLock:
-        simulation_directory_path = (
-            SimulationVisualizationDataManager.get_saved_simulation_directory_path(
-                simulation_id
-            )
-        )
-        return FileLock(f"{simulation_directory_path}/polylines.lock")
-
-    @staticmethod
-    def get_saved_simulation_polylines_directory_path(simulation_id: str) -> str:
-        simulation_directory_path = (
-            SimulationVisualizationDataManager.get_saved_simulation_directory_path(
-                simulation_id
-            )
-        )
-        directory_path = f"{simulation_directory_path}/{SimulationVisualizationDataManager.__POLYLINES_DIRECTORY_NAME}"
-
-        if not os.path.exists(directory_path):
-            os.makedirs(directory_path)
-
-        return directory_path
-
-    @staticmethod
-    def get_saved_simulation_polylines_version_file_path(simulation_id: str) -> str:
-        directory_path = SimulationVisualizationDataManager.get_saved_simulation_polylines_directory_path(
-            simulation_id
-        )
-        file_path = f"{directory_path}/{SimulationVisualizationDataManager.__POLYLINES_VERSION_FILE_NAME}"
-
-        if not os.path.exists(file_path):
-            with open(file_path, "w") as file:
-                file.write(str(0))
-
-        return file_path
-
-    @staticmethod
-    def set_polylines_version(simulation_id: str, version: int) -> None:
-        """
-        Should always be called in a lock.
-        """
-        file_path = SimulationVisualizationDataManager.get_saved_simulation_polylines_version_file_path(
-            simulation_id
-        )
-
-        with open(file_path, "w") as file:
-            file.write(str(version))
-
-    @staticmethod
-    def get_polylines_version(simulation_id: str) -> int:
-        """
-        Should always be called in a lock.
-        """
-        file_path = SimulationVisualizationDataManager.get_saved_simulation_polylines_version_file_path(
-            simulation_id
-        )
-
-        with open(file_path, "r") as file:
-            return int(file.read())
-
-    @staticmethod
-    def get_polylines_version_with_lock(simulation_id: str) -> int:
-        lock = SimulationVisualizationDataManager.get_saved_simulation_polylines_lock(
-            simulation_id
-        )
-        with lock:
-            return SimulationVisualizationDataManager.get_polylines_version(
-                simulation_id
-            )
-
-    @staticmethod
-    def get_saved_simulation_polylines_file_path(simulation_id: str) -> str:
-        directory_path = SimulationVisualizationDataManager.get_saved_simulation_polylines_directory_path(
-            simulation_id
-        )
-
-        file_path = f"{directory_path}/{SimulationVisualizationDataManager.__POLYLINES_FILE_NAME}.jsonl"
-
-        if not os.path.exists(file_path):
-            with open(file_path, "w") as file:
-                file.write("")
-
-        return file_path
-
-    @staticmethod
-    def set_polylines(
-        simulation_id: str, polylines: dict[str, tuple[str, list[float]]]
-    ) -> None:
-
-        file_path = (
-            SimulationVisualizationDataManager.get_saved_simulation_polylines_file_path(
-                simulation_id
-            )
-        )
-
-        lock = SimulationVisualizationDataManager.get_saved_simulation_polylines_lock(
-            simulation_id
-        )
-
-        with lock:
-            # Increment the version to notify the client that the polylines have changed
-            version = SimulationVisualizationDataManager.get_polylines_version(
-                simulation_id
-            )
-            version += 1
-            SimulationVisualizationDataManager.set_polylines_version(
-                simulation_id, version
-            )
-
-            with open(file_path, "a") as file:
-                for coordinates_string, (
-                    encoded_polyline,
-                    coefficients,
-                ) in polylines.items():
-                    data = {
-                        "coordinatesString": coordinates_string,
-                        "encodedPolyline": encoded_polyline,
-                        "coefficients": coefficients,
-                    }
-                    SimulationVisualizationDataManager.__format_json_one_line(
-                        data, file
-                    )
-
-    @staticmethod
-    def get_polylines(
-        simulation_id: str,
-    ) -> tuple[list[str], int]:
-
-        polylines = []
-
-        lock = SimulationVisualizationDataManager.get_saved_simulation_polylines_lock(
-            simulation_id
-        )
-
-        version = 0
-
-        with lock:
-            version = SimulationVisualizationDataManager.get_polylines_version(
-                simulation_id
-            )
-
-            file_path = SimulationVisualizationDataManager.get_saved_simulation_polylines_file_path(
-                simulation_id
-            )
-
-            with open(file_path, "r") as file:
-                for line in file:
-                    polylines.append(line)
-
-        return polylines, version
+# pylint: disable=too-many-lines
+import json
+import math
+import os
+from enum import Enum
+
+import multimodalsim.optimization.dispatcher  # (To avoid circular import error) pylint: disable=unused-import
+from filelock import FileLock
+from multimodalsim.simulator.environment import Environment
+from multimodalsim.simulator.request import Leg, Trip
+from multimodalsim.simulator.stop import Stop
+from multimodalsim.simulator.vehicle import Route, Vehicle
+from multimodalsim.state_machine.status import PassengerStatus, VehicleStatus
+
+from multimodalsim_viewer.common.utils import (
+    SAVE_VERSION,
+    SIMULATION_SAVE_FILE_SEPARATOR,
+    get_data_directory_path,
+)
+
+
+# MARK: Enums
+def convert_passenger_status_to_string(status: PassengerStatus) -> str:
+    if status == PassengerStatus.RELEASE:
+        return "release"
+    if status == PassengerStatus.ASSIGNED:
+        return "assigned"
+    if status == PassengerStatus.READY:
+        return "ready"
+    if status == PassengerStatus.ONBOARD:
+        return "onboard"
+    if status == PassengerStatus.COMPLETE:
+        return "complete"
+    raise ValueError(f"Unknown PassengerStatus {status}")
+
+
+def convert_vehicle_status_to_string(status: VehicleStatus) -> str:
+    if status == VehicleStatus.RELEASE:
+        return "release"
+    if status == VehicleStatus.IDLE:
+        return "idle"
+    if status == VehicleStatus.BOARDING:
+        return "boarding"
+    if status == VehicleStatus.ENROUTE:
+        return "enroute"
+    if status == VehicleStatus.ALIGHTING:
+        return "alighting"
+    if status == VehicleStatus.COMPLETE:
+        return "complete"
+    raise ValueError(f"Unknown VehicleStatus {status}")
+
+
+def convert_string_to_passenger_status(status: str) -> PassengerStatus:
+    if status == "release":
+        return PassengerStatus.RELEASE
+    if status == "assigned":
+        return PassengerStatus.ASSIGNED
+    if status == "ready":
+        return PassengerStatus.READY
+    if status == "onboard":
+        return PassengerStatus.ONBOARD
+    if status == "complete":
+        return PassengerStatus.COMPLETE
+    raise ValueError(f"Unknown PassengerStatus {status}")
+
+
+def convert_string_to_vehicle_status(status: str) -> VehicleStatus:
+    if status == "release":
+        return VehicleStatus.RELEASE
+    if status == "idle":
+        return VehicleStatus.IDLE
+    if status == "boarding":
+        return VehicleStatus.BOARDING
+    if status == "enroute":
+        return VehicleStatus.ENROUTE
+    if status == "alighting":
+        return VehicleStatus.ALIGHTING
+    if status == "complete":
+        return VehicleStatus.COMPLETE
+    raise ValueError(f"Unknown VehicleStatus {status}")
+
+
+# MARK: Serializable
+class Serializable:
+    def serialize(self) -> dict:
+        raise NotImplementedError()
+
+    @staticmethod
+    def deserialize(data: str) -> "Serializable":
+        """
+        Deserialize a dictionary into an instance of the class.
+
+        If the dictionary is not valid, return None.
+        """
+        raise NotImplementedError()
+
+
+# MARK: Leg
+class VisualizedLeg(Serializable):
+    assigned_vehicle_id: str | None
+    boarding_stop_index: int | None
+    alighting_stop_index: int | None
+    boarding_time: float | None
+    alighting_time: float | None
+    assigned_time: float | None
+    tags: list[str]
+
+    def __init__(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+        self,
+        assigned_vehicle_id: str | None,
+        boarding_stop_index: int | None,
+        alighting_stop_index: int | None,
+        boarding_time: float | None,
+        alighting_time: float | None,
+        assigned_time: float | None,
+        tags: list[str],
+    ) -> None:
+        self.assigned_vehicle_id = assigned_vehicle_id
+        self.boarding_stop_index = boarding_stop_index
+        self.alighting_stop_index = alighting_stop_index
+        self.boarding_time = boarding_time
+        self.alighting_time = alighting_time
+        self.assigned_time = assigned_time
+        self.tags = tags
+
+    @classmethod
+    def from_leg_environment_and_trip(  # pylint: disable=too-many-locals, too-many-branches
+        cls,
+        leg: Leg,
+        environment: Environment,
+        trip: Trip,
+        previous_leg: Leg | None = None,
+    ) -> "VisualizedLeg":
+        boarding_stop_index = None
+        alighting_stop_index = None
+
+        route = (
+            environment.get_route_by_vehicle_id(leg.assigned_vehicle.id) if leg.assigned_vehicle is not None else None
+        )
+
+        all_legs = trip.previous_legs + ([trip.current_leg] if trip.current_leg else []) + trip.next_legs
+
+        same_vehicle_leg_index = 0
+        for i, other_leg in enumerate(all_legs):
+            if other_leg.assigned_vehicle == leg.assigned_vehicle:
+                if other_leg == leg:
+                    break
+                same_vehicle_leg_index += 1
+
+        if route is not None:
+            all_stops = route.previous_stops.copy()
+            if route.current_stop is not None:
+                all_stops.append(route.current_stop)
+            all_stops += route.next_stops
+
+            trip_found_count = 0
+
+            for i, stop in enumerate(all_stops):
+                if boarding_stop_index is None and trip in (
+                    stop.passengers_to_board + stop.boarding_passengers + stop.boarded_passengers
+                ):
+                    if trip_found_count == same_vehicle_leg_index:
+                        boarding_stop_index = i
+                        break
+                    trip_found_count += 1
+
+            trip_found_count = 0
+
+            for i, stop in enumerate(all_stops):
+                if alighting_stop_index is None and trip in (
+                    stop.passengers_to_alight + stop.alighting_passengers + stop.alighted_passengers
+                ):
+                    if trip_found_count == same_vehicle_leg_index:
+                        alighting_stop_index = i
+                        break
+                    trip_found_count += 1
+
+        assigned_vehicle_id = leg.assigned_vehicle.id if leg.assigned_vehicle is not None else None
+
+        assigned_time = None
+        if assigned_vehicle_id is not None:
+            if previous_leg is not None and previous_leg.assigned_time is not None:
+                assigned_time = previous_leg.assigned_time
+            else:
+                assigned_time = environment.current_time
+
+        return cls(
+            assigned_vehicle_id,
+            boarding_stop_index,
+            alighting_stop_index,
+            leg.boarding_time,
+            leg.alighting_time,
+            assigned_time,
+            leg.tags,
+        )
+
+    def serialize(self) -> dict:
+        serialized = {}
+
+        if self.assigned_vehicle_id is not None:
+            serialized["assignedVehicleId"] = self.assigned_vehicle_id
+
+        if self.boarding_stop_index is not None:
+            serialized["boardingStopIndex"] = self.boarding_stop_index
+
+        if self.alighting_stop_index is not None:
+            serialized["alightingStopIndex"] = self.alighting_stop_index
+
+        if self.boarding_time is not None:
+            serialized["boardingTime"] = self.boarding_time
+
+        if self.alighting_time is not None:
+            serialized["alightingTime"] = self.alighting_time
+        if self.assigned_time is not None:
+            serialized["assignedTime"] = self.assigned_time
+
+        if len(self.tags) > 0:
+            serialized["tags"] = self.tags
+
+        return serialized
+
+    @staticmethod
+    def deserialize(data: str) -> "VisualizedLeg":
+        if isinstance(data, str):
+            data = json.loads(data.replace("'", '"'))
+
+        assigned_vehicle_id = data.get("assignedVehicleId", None)
+        boarding_stop_index = data.get("boardingStopIndex", None)
+        alighting_stop_index = data.get("alightingStopIndex", None)
+        boarding_time = data.get("boardingTime", None)
+        alighting_time = data.get("alightingTime", None)
+        assigned_time = data.get("assignedTime", None)
+        tags = data.get("tags", [])
+
+        return VisualizedLeg(
+            assigned_vehicle_id,
+            boarding_stop_index,
+            alighting_stop_index,
+            boarding_time,
+            alighting_time,
+            assigned_time,
+            tags,
+        )
+
+
+# MARK: Passenger
+class VisualizedPassenger(Serializable):  # pylint: disable=too-many-instance-attributes
+    passenger_id: str
+    name: str | None
+    status: PassengerStatus
+    number_of_passengers: int
+
+    previous_legs: list[VisualizedLeg]
+    current_leg: VisualizedLeg | None
+    next_legs: list[VisualizedLeg]
+
+    tags: list[str]
+
+    def __init__(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+        self,
+        passenger_id: str,
+        name: str | None,
+        status: PassengerStatus,
+        number_of_passengers: int,
+        previous_legs: list[VisualizedLeg],
+        current_leg: VisualizedLeg | None,
+        next_legs: list[VisualizedLeg],
+        tags: list[str],
+    ) -> None:
+        self.passenger_id = passenger_id
+        self.name = name
+        self.status = status
+        self.number_of_passengers = number_of_passengers
+
+        self.previous_legs = previous_legs
+        self.current_leg = current_leg
+        self.next_legs = next_legs
+
+        self.tags = tags
+
+    @classmethod
+    def from_trip_and_environment(cls, trip: Trip, environment: Environment) -> "VisualizedPassenger":
+        previous_legs = [
+            VisualizedLeg.from_leg_environment_and_trip(leg, environment, trip) for leg in trip.previous_legs
+        ]
+        current_leg = (
+            VisualizedLeg.from_leg_environment_and_trip(trip.current_leg, environment, trip)
+            if trip.current_leg is not None
+            else None
+        )
+        next_legs = [VisualizedLeg.from_leg_environment_and_trip(leg, environment, trip) for leg in trip.next_legs]
+
+        return cls(
+            trip.id, trip.name, trip.status, trip.nb_passengers, previous_legs, current_leg, next_legs, trip.tags
+        )
+
+    def serialize(self) -> dict:
+        serialized = {
+            "id": self.passenger_id,
+            "status": convert_passenger_status_to_string(self.status),
+            "numberOfPassengers": self.number_of_passengers,
+        }
+
+        if self.name is not None:
+            serialized["name"] = self.name
+
+        serialized["previousLegs"] = [leg.serialize() for leg in self.previous_legs]
+
+        if self.current_leg is not None:
+            serialized["currentLeg"] = self.current_leg.serialize()
+
+        serialized["nextLegs"] = [leg.serialize() for leg in self.next_legs]
+
+        if len(self.tags) > 0:
+            serialized["tags"] = self.tags
+
+        return serialized
+
+    @staticmethod
+    def deserialize(data: str) -> "VisualizedPassenger":
+        if isinstance(data, str):
+            data = json.loads(data.replace("'", '"'))
+
+        if (
+            "id" not in data
+            or "status" not in data
+            or "previousLegs" not in data
+            or "nextLegs" not in data
+            or "numberOfPassengers" not in data
+        ):
+            raise ValueError("Invalid data for VisualizedPassenger")
+
+        passenger_id = str(data["id"])
+        name = data.get("name", None)
+        status = convert_string_to_passenger_status(data["status"])
+        number_of_passengers = int(data["numberOfPassengers"])
+
+        previous_legs = [VisualizedLeg.deserialize(leg_data) for leg_data in data["previousLegs"]]
+        next_legs = [VisualizedLeg.deserialize(leg_data) for leg_data in data["nextLegs"]]
+
+        current_leg = data.get("currentLeg", None)
+        if current_leg is not None:
+            current_leg = VisualizedLeg.deserialize(current_leg)
+
+        tags = data.get("tags", [])
+
+        return VisualizedPassenger(
+            passenger_id, name, status, number_of_passengers, previous_legs, current_leg, next_legs, tags
+        )
+
+
+# MARK: Stop
+class VisualizedStop(Serializable):
+    arrival_time: float
+    departure_time: float | None
+    latitude: float | None
+    longitude: float | None
+    capacity: int | None
+    label: str
+    tags: list[str]
+
+    def __init__(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+        self,
+        arrival_time: float,
+        departure_time: float,
+        latitude: float | None,
+        longitude: float | None,
+        capacity: int | None,
+        label: str,
+        tags: str,
+    ) -> None:
+        self.arrival_time = arrival_time
+        self.departure_time = departure_time
+        self.latitude = latitude
+        self.longitude = longitude
+        self.capacity = capacity
+        self.label = label
+        self.tags = tags
+
+    @classmethod
+    def from_stop(cls, stop: Stop) -> "VisualizedStop":
+        return cls(
+            stop.arrival_time,
+            stop.departure_time if stop.departure_time != math.inf else None,
+            stop.location.lat,
+            stop.location.lon,
+            stop.capacity,
+            stop.location.label,
+            stop.tags,
+        )
+
+    def serialize(self) -> dict:
+        serialized = {"arrivalTime": self.arrival_time}
+
+        if self.departure_time is not None:
+            serialized["departureTime"] = self.departure_time
+
+        if self.latitude is not None and self.longitude is not None:
+            serialized["position"] = {
+                "latitude": self.latitude,
+                "longitude": self.longitude,
+            }
+
+        if self.capacity is not None:
+            serialized["capacity"] = self.capacity
+
+        serialized["label"] = self.label
+
+        if len(self.tags) > 0:
+            serialized["tags"] = self.tags
+
+        return serialized
+
+    @staticmethod
+    def deserialize(data: str) -> "VisualizedStop":
+        if isinstance(data, str):
+            data = json.loads(data.replace("'", '"'))
+
+        if "arrivalTime" not in data or "label" not in data:
+            raise ValueError("Invalid data for VisualizedStop")
+
+        arrival_time = float(data["arrivalTime"])
+        departure_time = data.get("departureTime", None)
+
+        latitude = None
+        longitude = None
+
+        position = data.get("position", None)
+
+        if position is not None:
+            latitude = position.get("latitude", None)
+            longitude = position.get("longitude", None)
+
+        capacity = data.get("capacity", None)
+
+        if capacity is not None:
+            capacity = int(capacity)
+
+        label = data["label"]
+
+        tags = data.get("tags", [])
+
+        return VisualizedStop(arrival_time, departure_time, latitude, longitude, capacity, label, tags)
+
+
+# MARK: Vehicle
+class VisualizedVehicle(Serializable):  # pylint: disable=too-many-instance-attributes
+    vehicle_id: str
+    mode: str | None
+    status: VehicleStatus
+    polylines: dict[str, tuple[str, list[float]]] | None
+    previous_stops: list[VisualizedStop]
+    current_stop: VisualizedStop | None
+    next_stops: list[VisualizedStop]
+    capacity: int
+    name: str | None
+    tags: list[str]
+
+    def __init__(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+        self,
+        vehicle_id: str | int,
+        mode: str | None,
+        status: VehicleStatus,
+        polylines: dict[str, tuple[str, list[float]]] | None,
+        previous_stops: list[VisualizedStop],
+        current_stop: VisualizedStop | None,
+        next_stops: list[VisualizedStop],
+        capacity: int,
+        name: str | None,
+        tags: list[str],
+    ) -> None:
+        self.vehicle_id = str(vehicle_id)
+        self.mode = mode
+        self.status = status
+        self.polylines = polylines
+
+        self.previous_stops = previous_stops
+        self.current_stop = current_stop
+        self.next_stops = next_stops
+
+        self.capacity = capacity
+        self.name = name
+
+        self.tags = tags
+
+    @property
+    def all_stops(self) -> list[VisualizedStop]:
+        return self.previous_stops + ([self.current_stop] if self.current_stop is not None else []) + self.next_stops
+
+    @classmethod
+    def from_vehicle_and_route(cls, vehicle: Vehicle, route: Route) -> "VisualizedVehicle":
+        previous_stops = [VisualizedStop.from_stop(stop) for stop in route.previous_stops]
+        current_stop = VisualizedStop.from_stop(route.current_stop) if route.current_stop is not None else None
+        next_stops = [VisualizedStop.from_stop(stop) for stop in route.next_stops]
+        return cls(
+            vehicle.id,
+            vehicle.mode,
+            vehicle.status,
+            vehicle.polylines,
+            previous_stops,
+            current_stop,
+            next_stops,
+            vehicle.capacity,
+            vehicle.name,
+            vehicle.tags,
+        )
+
+    def serialize(self) -> dict:
+        serialized = {
+            "id": self.vehicle_id,
+            "status": convert_vehicle_status_to_string(self.status),
+            "previousStops": [stop.serialize() for stop in self.previous_stops],
+            "nextStops": [stop.serialize() for stop in self.next_stops],
+            "capacity": self.capacity,
+            "name": self.name,
+        }
+
+        if self.mode is not None:
+            serialized["mode"] = self.mode
+
+        if self.current_stop is not None:
+            serialized["currentStop"] = self.current_stop.serialize()
+
+        if len(self.tags) > 0:
+            serialized["tags"] = self.tags
+
+        return serialized
+
+    @staticmethod
+    def deserialize(data: str | dict) -> "VisualizedVehicle":
+        if isinstance(data, str):
+            data = json.loads(data.replace("'", '"'))
+
+        required_keys = [
+            "id",
+            "status",
+            "previousStops",
+            "nextStops",
+            "capacity",
+            "name",
+        ]
+        if any(key not in data for key in required_keys):
+            raise ValueError("Invalid data for VisualizedVehicle")
+
+        vehicle_id = str(data["id"])
+        mode = data.get("mode", None)
+        status = convert_string_to_vehicle_status(data["status"])
+        previous_stops = [VisualizedStop.deserialize(stop_data) for stop_data in data["previousStops"]]
+        next_stops = [VisualizedStop.deserialize(stop_data) for stop_data in data["nextStops"]]
+        capacity = int(data["capacity"])
+        name = data.get("name", None)
+
+        current_stop = data.get("currentStop", None)
+        if current_stop is not None:
+            current_stop = VisualizedStop.deserialize(current_stop)
+
+        tags = data.get("tags", [])
+
+        return VisualizedVehicle(
+            vehicle_id, mode, status, None, previous_stops, current_stop, next_stops, capacity, name, tags
+        )
+
+
+# MARK: Environment
+class VisualizedEnvironment(Serializable):
+    passengers: dict[str, VisualizedPassenger]
+    vehicles: dict[str, VisualizedVehicle]
+    statistic: dict[str, dict[str, dict[str, int]]]
+    timestamp: float
+    estimated_end_time: float
+    order: int
+
+    def __init__(self) -> None:
+        self.passengers = {}
+        self.vehicles = {}
+        self.timestamp = 0
+        self.estimated_end_time = 0
+        self.order = 0
+        self.statistic = None
+
+    def add_passenger(self, passenger: VisualizedPassenger) -> None:
+        self.passengers[passenger.passenger_id] = passenger
+
+    def get_passenger(self, passenger_id: str) -> VisualizedPassenger:
+        if passenger_id in self.passengers:
+            return self.passengers[passenger_id]
+        raise ValueError(f"Passenger {passenger_id} not found")
+
+    def add_vehicle(self, vehicle: VisualizedVehicle) -> None:
+        self.vehicles[vehicle.vehicle_id] = vehicle
+
+    def get_vehicle(self, vehicle_id: str) -> VisualizedVehicle:
+        if vehicle_id in self.vehicles:
+            return self.vehicles[vehicle_id]
+        raise ValueError(f"Vehicle {vehicle_id} not found")
+
+    def serialize(self) -> dict:
+        return {
+            "passengers": [passenger.serialize() for passenger in self.passengers.values()],
+            "vehicles": [vehicle.serialize() for vehicle in self.vehicles.values()],
+            "timestamp": self.timestamp,
+            "estimatedEndTime": self.estimated_end_time,
+            "statistic": self.statistic if self.statistic is not None else {},
+            "order": self.order,
+        }
+
+    @staticmethod
+    def deserialize(data: str) -> "VisualizedEnvironment":
+        if isinstance(data, str):
+            data = json.loads(data.replace("'", '"'))
+
+        required_keys = [
+            "passengers",
+            "vehicles",
+            "timestamp",
+            "estimatedEndTime",
+            "statistic",
+            "order",
+        ]
+        if any(key not in data for key in required_keys):
+            raise ValueError("Invalid data for VisualizedEnvironment")
+
+        environment = VisualizedEnvironment()
+        for passenger_data in data["passengers"]:
+            passenger = VisualizedPassenger.deserialize(passenger_data)
+            environment.add_passenger(passenger)
+
+        for vehicle_data in data["vehicles"]:
+            vehicle = VisualizedVehicle.deserialize(vehicle_data)
+            environment.add_vehicle(vehicle)
+
+        environment.timestamp = data["timestamp"]
+        environment.estimated_end_time = data["estimatedEndTime"]
+        environment.statistic = data["statistic"]
+        environment.order = data["order"]
+
+        return environment
+
+
+# MARK: Updates
+class UpdateType(Enum):
+    CREATE_PASSENGER = "createPassenger"
+    CREATE_VEHICLE = "createVehicle"
+    UPDATE_PASSENGER_STATUS = "updatePassengerStatus"
+    UPDATE_PASSENGER_LEGS = "updatePassengerLegs"
+    UPDATE_VEHICLE_STATUS = "updateVehicleStatus"
+    UPDATE_VEHICLE_STOPS = "updateVehicleStops"
+    UPDATE_STATISTIC = "updateStatistic"
+
+
+class StatisticUpdate(Serializable):
+    statistic: dict[str, dict[str, dict[str, int]]]
+
+    def __init__(self, statistic: dict) -> None:
+        self.statistic = statistic
+
+    def serialize(self) -> dict[str, dict[str, dict[str, int]]]:
+        return {"statistic": self.statistic}
+
+    @staticmethod
+    def deserialize(data: str) -> "StatisticUpdate":
+        if isinstance(data, str):
+            data = json.loads(data.replace("'", '"'))
+
+        if "statistic" not in data:
+            raise ValueError("Invalid data for StatisticUpdate")
+
+        return StatisticUpdate(data.statistic)
+
+
+class PassengerStatusUpdate(Serializable):
+    passenger_id: str
+    status: PassengerStatus
+
+    def __init__(self, passenger_id: str, status: PassengerStatus) -> None:
+        self.passenger_id = passenger_id
+        self.status = status
+
+    @classmethod
+    def from_trip(cls, trip: Trip) -> "PassengerStatusUpdate":
+        return cls(trip.id, trip.status)
+
+    def serialize(self) -> dict:
+        return {
+            "id": self.passenger_id,
+            "status": convert_passenger_status_to_string(self.status),
+        }
+
+    @staticmethod
+    def deserialize(data: str) -> "PassengerStatusUpdate":
+        if isinstance(data, str):
+            data = json.loads(data.replace("'", '"'))
+
+        if "id" not in data or "status" not in data:
+            raise ValueError("Invalid data for PassengerStatusUpdate")
+
+        passenger_id = str(data["id"])
+        status = convert_string_to_passenger_status(data["status"])
+        return PassengerStatusUpdate(passenger_id, status)
+
+
+class PassengerLegsUpdate(Serializable):
+    passenger_id: str
+    previous_legs: list[VisualizedLeg]
+    current_leg: VisualizedLeg | None
+    next_legs: list[VisualizedLeg]
+
+    def __init__(
+        self,
+        passenger_id: str,
+        previous_legs: list[VisualizedLeg],
+        current_leg: VisualizedLeg | None,
+        next_legs: list[VisualizedLeg],
+    ) -> None:
+        self.passenger_id = passenger_id
+        self.previous_legs = previous_legs
+        self.current_leg = current_leg
+        self.next_legs = next_legs
+
+    @classmethod
+    def from_trip_environment_and_previous_passenger(
+        cls,
+        trip: Trip,
+        environment: Environment,
+        previous_passenger: VisualizedPassenger,
+    ) -> "PassengerLegsUpdate":
+        all_previous_legs = (
+            previous_passenger.previous_legs
+            + ([previous_passenger.current_leg] if previous_passenger.current_leg is not None else [])
+            + previous_passenger.next_legs
+        )
+        current_index = 0
+
+        previous_legs = []
+        for leg in trip.previous_legs:
+            previous_leg = None
+            if current_index < len(all_previous_legs):
+                previous_leg = all_previous_legs[current_index]
+                current_index += 1
+            previous_legs.append(VisualizedLeg.from_leg_environment_and_trip(leg, environment, trip, previous_leg))
+
+        previous_leg = None
+        if trip.current_leg is not None and current_index < len(all_previous_legs):
+            previous_leg = all_previous_legs[current_index]
+            current_index += 1
+        current_leg = (
+            VisualizedLeg.from_leg_environment_and_trip(trip.current_leg, environment, trip, previous_leg)
+            if trip.current_leg is not None
+            else None
+        )
+
+        next_legs = []
+        for leg in trip.next_legs:
+            next_leg = None
+            if current_index < len(all_previous_legs):
+                next_leg = all_previous_legs[current_index]
+                current_index += 1
+            next_legs.append(VisualizedLeg.from_leg_environment_and_trip(leg, environment, trip, next_leg))
+
+        return cls(trip.id, previous_legs, current_leg, next_legs)
+
+    def serialize(self) -> dict:
+        serialized = {
+            "id": self.passenger_id,
+            "previousLegs": [leg.serialize() for leg in self.previous_legs],
+            "nextLegs": [leg.serialize() for leg in self.next_legs],
+        }
+
+        if self.current_leg is not None:
+            serialized["currentLeg"] = self.current_leg.serialize()
+
+        return serialized
+
+    @staticmethod
+    def deserialize(data: str) -> "PassengerLegsUpdate":
+        if isinstance(data, str):
+            data = json.loads(data.replace("'", '"'))
+
+        if "id" not in data or "previousLegs" not in data or "nextLegs" not in data:
+            raise ValueError("Invalid data for PassengerLegsUpdate")
+
+        passenger_id = str(data["id"])
+        previous_legs = [VisualizedLeg.deserialize(leg_data) for leg_data in data["previousLegs"]]
+        next_legs = [VisualizedLeg.deserialize(leg_data) for leg_data in data["nextLegs"]]
+
+        current_leg = data.get("currentLeg", None)
+        if current_leg is not None:
+            current_leg = VisualizedLeg.deserialize(current_leg)
+
+        return PassengerLegsUpdate(passenger_id, previous_legs, current_leg, next_legs)
+
+
+class VehicleStatusUpdate(Serializable):
+    vehicle_id: str
+    status: VehicleStatus
+
+    def __init__(self, vehicle_id: str, status: VehicleStatus) -> None:
+        self.vehicle_id = vehicle_id
+        self.status = status
+
+    @classmethod
+    def from_vehicle(cls, vehicle: Vehicle) -> "VehicleStatusUpdate":
+        return cls(vehicle.id, vehicle.status)
+
+    def serialize(self) -> dict:
+        return {
+            "id": self.vehicle_id,
+            "status": convert_vehicle_status_to_string(self.status),
+        }
+
+    @staticmethod
+    def deserialize(data: str) -> "VehicleStatusUpdate":
+        if isinstance(data, str):
+            data = json.loads(data.replace("'", '"'))
+
+        if "id" not in data or "status" not in data:
+            raise ValueError("Invalid data for VehicleStatusUpdate")
+
+        vehicle_id = str(data["id"])
+        status = convert_string_to_vehicle_status(data["status"])
+        return VehicleStatusUpdate(vehicle_id, status)
+
+
+class VehicleStopsUpdate(Serializable):
+    vehicle_id: str
+    previous_stops: list[VisualizedStop]
+    current_stop: VisualizedStop | None
+    next_stops: list[VisualizedStop]
+
+    def __init__(
+        self,
+        vehicle_id: str,
+        previous_stops: list[VisualizedStop],
+        current_stop: VisualizedStop | None,
+        next_stops: list[VisualizedStop],
+    ) -> None:
+        self.vehicle_id = vehicle_id
+        self.previous_stops = previous_stops
+        self.current_stop = current_stop
+        self.next_stops = next_stops
+
+    @classmethod
+    def from_vehicle_and_route(cls, vehicle: Vehicle, route: Route) -> "VehicleStopsUpdate":
+        previous_stops = [VisualizedStop.from_stop(stop) for stop in route.previous_stops]
+        current_stop = VisualizedStop.from_stop(route.current_stop) if route.current_stop is not None else None
+        next_stops = [VisualizedStop.from_stop(stop) for stop in route.next_stops]
+        return cls(vehicle.id, previous_stops, current_stop, next_stops)
+
+    def serialize(self) -> dict:
+        serialized = {
+            "id": self.vehicle_id,
+            "previousStops": [stop.serialize() for stop in self.previous_stops],
+            "nextStops": [stop.serialize() for stop in self.next_stops],
+        }
+
+        if self.current_stop is not None:
+            serialized["currentStop"] = self.current_stop.serialize()
+
+        return serialized
+
+    @staticmethod
+    def deserialize(data: str) -> "VehicleStopsUpdate":
+        if isinstance(data, str):
+            data = json.loads(data.replace("'", '"'))
+
+        if "id" not in data or "previousStops" not in data or "nextStops" not in data:
+            raise ValueError("Invalid data for VehicleStopsUpdate")
+
+        vehicle_id = str(data["id"])
+        previous_stops = [VisualizedStop.deserialize(stop_data) for stop_data in data["previousStops"]]
+        next_stops = [VisualizedStop.deserialize(stop_data) for stop_data in data["nextStops"]]
+
+        current_stop = data.get("currentStop", None)
+        if current_stop is not None:
+            current_stop = VisualizedStop.deserialize(current_stop)
+
+        return VehicleStopsUpdate(vehicle_id, previous_stops, current_stop, next_stops)
+
+
+class Update(Serializable):
+    update_type: UpdateType
+    data: Serializable
+    timestamp: float
+    order: int
+
+    def __init__(
+        self,
+        update_type: UpdateType,
+        data: Serializable,
+        timestamp: float,
+    ) -> None:
+        self.update_type = update_type
+        self.data = data
+        self.timestamp = timestamp
+        self.order = 0
+
+    def serialize(self) -> dict:
+        return {
+            "type": self.update_type.value,
+            "data": self.data.serialize(),
+            "timestamp": self.timestamp,
+            "order": self.order,
+        }
+
+    @staticmethod
+    def deserialize(data: str) -> "Update":
+        if isinstance(data, str):
+            data = json.loads(data.replace("'", '"'))
+
+        if "type" not in data or "data" not in data or "timestamp" not in data or "order" not in data:
+            raise ValueError("Invalid data for Update")
+
+        update_type = UpdateType(data["type"])
+        update_data = data["data"]
+        timestamp = float(data["timestamp"])
+
+        if update_type == UpdateType.CREATE_PASSENGER:
+            update_data = VisualizedPassenger.deserialize(update_data)
+        elif update_type == UpdateType.CREATE_VEHICLE:
+            update_data = VisualizedVehicle.deserialize(update_data)
+        elif update_type == UpdateType.UPDATE_PASSENGER_STATUS:
+            update_data = PassengerStatusUpdate.deserialize(update_data)
+        elif update_type == UpdateType.UPDATE_PASSENGER_LEGS:
+            update_data = PassengerLegsUpdate.deserialize(update_data)
+        elif update_type == UpdateType.UPDATE_VEHICLE_STATUS:
+            update_data = VehicleStatusUpdate.deserialize(update_data)
+        elif update_type == UpdateType.UPDATE_VEHICLE_STOPS:
+            update_data = VehicleStopsUpdate.deserialize(update_data)
+        elif update_type == UpdateType.UPDATE_STATISTIC:
+            update_data = StatisticUpdate.deserialize(update_data)
+
+        update = Update(update_type, update_data, timestamp)
+        update.order = data["order"]
+        return update
+
+
+# MARK: State
+class VisualizedState(VisualizedEnvironment):
+    updates: list[Update]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.updates = []
+
+    @classmethod
+    def from_environment(cls, environment: VisualizedEnvironment) -> "VisualizedState":
+        state = cls()
+        state.passengers = environment.passengers
+        state.vehicles = environment.vehicles
+        state.timestamp = environment.timestamp
+        state.estimated_end_time = environment.estimated_end_time
+        state.order = environment.order
+        return state
+
+    def serialize(self) -> dict:
+        serialized = super().serialize()
+        serialized["updates"] = [update.serialize() for update in self.updates]
+        return serialized
+
+    @staticmethod
+    def deserialize(data: str) -> "VisualizedState":
+        if isinstance(data, str):
+            data = json.loads(data.replace("'", '"'))
+
+        if "updates" not in data:
+            raise ValueError("Invalid data for VisualizedState")
+
+        environment = VisualizedEnvironment.deserialize(data)
+
+        state = VisualizedState()
+        state.passengers = environment.passengers
+        state.vehicles = environment.vehicles
+        state.timestamp = environment.timestamp
+        state.estimated_end_time = environment.estimated_end_time
+        state.order = environment.order
+
+        for update_data in data["updates"]:
+            update = Update.deserialize(update_data)
+            state.updates.append(update)
+
+        return state
+
+
+# MARK: Simulation Information
+class SimulationInformation(Serializable):  # pylint: disable=too-many-instance-attributes
+    version: int
+    simulation_id: str
+    name: str
+    start_time: str
+    data: str
+    simulation_start_time: float | None
+    simulation_end_time: float | None
+    last_update_order: int | None
+
+    def __init__(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+        self,
+        simulation_id: str,
+        data: str,
+        simulation_start_time: str | None,
+        simulation_end_time: str | None,
+        last_update_order: int | None,
+        version: int | None,
+    ) -> None:
+        self.version = version
+        if self.version is None:
+            self.version = SAVE_VERSION
+
+        self.simulation_id = simulation_id
+
+        self.name = simulation_id.split(SIMULATION_SAVE_FILE_SEPARATOR)[1]
+        self.start_time = simulation_id.split(SIMULATION_SAVE_FILE_SEPARATOR)[0]
+        self.data = data
+
+        self.simulation_start_time = simulation_start_time
+        self.simulation_end_time = simulation_end_time
+        self.last_update_order = last_update_order
+
+    def serialize(self) -> dict:
+        serialized = {
+            "version": self.version,
+            "simulationId": self.simulation_id,
+            "name": self.name,
+            "startTime": self.start_time,
+            "data": self.data,
+        }
+        if self.simulation_start_time is not None:
+            serialized["simulationStartTime"] = self.simulation_start_time
+        if self.simulation_end_time is not None:
+            serialized["simulationEndTime"] = self.simulation_end_time
+        if self.last_update_order is not None:
+            serialized["lastUpdateOrder"] = self.last_update_order
+        return serialized
+
+    @staticmethod
+    def deserialize(data: str) -> "SimulationInformation":
+        if isinstance(data, str):
+            data = json.loads(data.replace("'", '"'))
+
+        if "version" not in data or "simulationId" not in data:
+            raise ValueError("Invalid data for SimulationInformation")
+
+        version = int(data["version"])
+        simulation_id = str(data["simulationId"])
+        simulation_data = str(data["data"])
+
+        simulation_start_time = data.get("simulationStartTime", None)
+        simulation_end_time = data.get("simulationEndTime", None)
+        last_update_order = data.get("lastUpdateOrder", None)
+
+        return SimulationInformation(
+            simulation_id,
+            simulation_data,
+            simulation_start_time,
+            simulation_end_time,
+            last_update_order,
+            version,
+        )
+
+
+# MARK: SVDM
+class SimulationVisualizationDataManager:  # pylint: disable=too-many-public-methods
+    """
+    This class manage reads and writes of simulation data for visualization.
+    """
+
+    __CORRUPTED_FILE_NAME = ".corrupted"
+    __SAVED_SIMULATIONS_DIRECTORY_NAME = "saved_simulations"
+    __SIMULATION_INFORMATION_FILE_NAME = "simulation_information.json"
+    __STATES_DIRECTORY_NAME = "states"
+    __POLYLINES_DIRECTORY_NAME = "polylines"
+    __POLYLINES_FILE_NAME = "polylines"
+    __POLYLINES_VERSION_FILE_NAME = "version"
+
+    __STATES_ORDER_MINIMUM_LENGTH = 8
+    __STATES_TIMESTAMP_MINIMUM_LENGTH = 8
+
+    # Only send a maximum of __MAX_STATES_AT_ONCE states at once
+    # This should be at least 2
+    __MAX_STATES_AT_ONCE = 2
+
+    # The client keeps a maximum of __MAX_STATES_IN_CLIENT_BEFORE_NECESSARY + __MAX_STATES_IN_CLIENT_AFTER_NECESSARY + 1
+    # states in memory
+    # The current one, the previous __MAX_STATES_IN_CLIENT_BEFORE_NECESSARY and
+    # the next __MAX_STATES_IN_CLIENT_AFTER_NECESSARY
+    # __MAX_STATES_IN_CLIENT_BEFORE_NECESSARY = 24
+    # __MAX_STATES_IN_CLIENT_AFTER_NECESSARY = 50
+
+    # MARK: +- Format
+    @staticmethod
+    def __format_json_readable(data: dict, file: str) -> str:
+        return json.dump(data, file, indent=2, separators=(",", ": "), sort_keys=True)
+
+    @staticmethod
+    def __format_json_one_line(data: dict, file: str) -> str:
+        # Add new line before if not empty
+        if file.tell() != 0:
+            file.write("\n")
+        return json.dump(data, file, separators=(",", ":"))
+
+    # MARK: +- File paths
+    @staticmethod
+    def get_saved_simulations_directory_path() -> str:
+        directory_path = os.path.join(
+            get_data_directory_path(), SimulationVisualizationDataManager.__SAVED_SIMULATIONS_DIRECTORY_NAME
+        )
+
+        if not os.path.exists(directory_path):
+            os.makedirs(directory_path)
+
+        return directory_path
+
+    @staticmethod
+    def get_all_saved_simulation_ids() -> list[str]:
+        directory_path = SimulationVisualizationDataManager.get_saved_simulations_directory_path()
+        return os.listdir(directory_path)
+
+    @staticmethod
+    def get_saved_simulation_directory_path(simulation_id: str, should_create=False) -> str:
+        directory_path = SimulationVisualizationDataManager.get_saved_simulations_directory_path()
+        simulation_directory_path = f"{directory_path}/{simulation_id}"
+
+        if should_create and not os.path.exists(simulation_directory_path):
+            os.makedirs(simulation_directory_path)
+
+        return simulation_directory_path
+
+    # MARK: +- Folder size
+    @staticmethod
+    def _get_folder_size(start_path: str) -> int:
+        total_size = 0
+        for directory_path, _, file_names in os.walk(start_path):
+            file_names = [name for name in file_names if not name.endswith(".lock")]
+            for file_name in file_names:
+                file_path = os.path.join(directory_path, file_name)
+                lock = FileLock(f"{file_path}.lock")
+                with lock:
+                    total_size += os.path.getsize(file_path)
+        return total_size
+
+    @staticmethod
+    def get_saved_simulation_size(simulation_id: str) -> int:
+        simulation_directory_path = SimulationVisualizationDataManager.get_saved_simulation_directory_path(
+            simulation_id
+        )
+        return SimulationVisualizationDataManager._get_folder_size(simulation_directory_path)
+
+    # MARK: +- Corrupted
+    @staticmethod
+    def is_simulation_corrupted(simulation_id: str) -> bool:
+        simulation_directory_path = SimulationVisualizationDataManager.get_saved_simulation_directory_path(
+            simulation_id, True
+        )
+
+        return os.path.exists(f"{simulation_directory_path}/{SimulationVisualizationDataManager.__CORRUPTED_FILE_NAME}")
+
+    @staticmethod
+    def mark_simulation_as_corrupted(simulation_id: str) -> None:
+        simulation_directory_path = SimulationVisualizationDataManager.get_saved_simulation_directory_path(
+            simulation_id, True
+        )
+
+        file_path = f"{simulation_directory_path}/{SimulationVisualizationDataManager.__CORRUPTED_FILE_NAME}"
+
+        with open(file_path, "w", encoding="utf-8") as file:
+            file.write("")
+
+    # MARK: +- Simulation Information
+    @staticmethod
+    def get_saved_simulation_information_file_path(simulation_id: str) -> str:
+        simulation_directory_path = SimulationVisualizationDataManager.get_saved_simulation_directory_path(
+            simulation_id, True
+        )
+        file_path = (
+            f"{simulation_directory_path}/{SimulationVisualizationDataManager.__SIMULATION_INFORMATION_FILE_NAME}"
+        )
+
+        if not os.path.exists(file_path):
+            with open(file_path, "w", encoding="utf-8") as file:
+                file.write("")
+
+        return file_path
+
+    @staticmethod
+    def set_simulation_information(simulation_id: str, simulation_information: SimulationInformation) -> None:
+        file_path = SimulationVisualizationDataManager.get_saved_simulation_information_file_path(simulation_id)
+
+        lock = FileLock(f"{file_path}.lock")
+
+        with lock:
+            with open(file_path, "w", encoding="utf-8") as file:
+                SimulationVisualizationDataManager.__format_json_readable(simulation_information.serialize(), file)
+
+    @staticmethod
+    def get_simulation_information(simulation_id: str) -> SimulationInformation:
+        file_path = SimulationVisualizationDataManager.get_saved_simulation_information_file_path(simulation_id)
+
+        lock = FileLock(f"{file_path}.lock")
+
+        simulation_information = None
+        should_update_simulation_information = False
+
+        with lock:
+            with open(file_path, "r", encoding="utf-8") as file:
+                data = file.read()
+
+                simulation_information = SimulationInformation.deserialize(data)
+
+                # Handle mismatched simulation_id, name, or start_time because of uploads
+                # where the simulation folder has been renamed due to duplicates.
+                start_time, name = simulation_id.split(SIMULATION_SAVE_FILE_SEPARATOR)
+
+                if (
+                    simulation_id != simulation_information.simulation_id
+                    or name != simulation_information.name
+                    or start_time != simulation_information.start_time
+                ):
+                    simulation_information.simulation_id = simulation_id
+                    simulation_information.name = name
+                    simulation_information.start_time = start_time
+
+        if simulation_information is not None and should_update_simulation_information:
+            SimulationVisualizationDataManager.set_simulation_information(simulation_id, simulation_information)
+
+        return simulation_information
+
+    # MARK: +- States and updates
+    @staticmethod
+    def get_saved_simulation_states_folder_path(simulation_id: str) -> str:
+        simulation_directory_path = SimulationVisualizationDataManager.get_saved_simulation_directory_path(
+            simulation_id, True
+        )
+        folder_path = f"{simulation_directory_path}/{SimulationVisualizationDataManager.__STATES_DIRECTORY_NAME}"
+
+        if not os.path.exists(folder_path):
+            os.makedirs(folder_path)
+
+        return folder_path
+
+    @staticmethod
+    def get_saved_simulation_state_file_path(simulation_id: str, order: int, timestamp: float) -> str:
+        folder_path = SimulationVisualizationDataManager.get_saved_simulation_states_folder_path(simulation_id)
+
+        padded_order = str(order).zfill(SimulationVisualizationDataManager.__STATES_ORDER_MINIMUM_LENGTH)
+        padded_timestamp = str(int(timestamp)).zfill(
+            SimulationVisualizationDataManager.__STATES_TIMESTAMP_MINIMUM_LENGTH
+        )
+
+        # States and updates are stored in a .jsonl file to speed up reads and writes
+        # Each line is a state (the first line) or an update (the following lines)
+        file_path = f"{folder_path}/{padded_order}-{padded_timestamp}.jsonl"
+
+        if not os.path.exists(file_path):
+            with open(file_path, "w", encoding="utf-8") as file:
+                file.write("")
+
+        return file_path
+
+    @staticmethod
+    def get_sorted_states(simulation_id: str) -> list[tuple[int, float]]:
+        folder_path = SimulationVisualizationDataManager.get_saved_simulation_states_folder_path(simulation_id)
+
+        all_states_files = [
+            path for path in os.listdir(folder_path) if path.endswith(".jsonl")
+        ]  # Filter out lock files
+
+        states = []
+        for state_file in all_states_files:
+            order, timestamp = state_file.split("-")
+            states.append((int(order), float(timestamp.split(".")[0])))
+
+        return sorted(states, key=lambda x: (x[1], x[0]))
+
+    @staticmethod
+    def save_state(simulation_id: str, environment: VisualizedEnvironment) -> str:
+        file_path = SimulationVisualizationDataManager.get_saved_simulation_state_file_path(
+            simulation_id, environment.order, environment.timestamp
+        )
+
+        lock = FileLock(f"{file_path}.lock")
+
+        with lock:
+            with open(file_path, "w", encoding="utf-8") as file:
+                SimulationVisualizationDataManager.__format_json_one_line(environment.serialize(), file)
+
+        return file_path
+
+    @staticmethod
+    def save_update(file_path: str, update: Update) -> None:
+        lock = FileLock(f"{file_path}.lock")
+        with lock:
+            with open(file_path, "a", encoding="utf-8") as file:
+                SimulationVisualizationDataManager.__format_json_one_line(update.serialize(), file)
+
+    @staticmethod
+    def get_missing_states(  # pylint: disable=too-many-locals, too-many-branches, too-many-statements
+        simulation_id: str,
+        visualization_time: float,
+        loaded_state_orders: list[int],
+        is_simulation_complete: bool,
+    ) -> tuple[list[str], dict[list[str]], list[int], bool, int, int, int]:
+        sorted_states = SimulationVisualizationDataManager.get_sorted_states(simulation_id)
+
+        if len(sorted_states) == 0:
+            return ([], {}, [], False, 0, 0, 0)
+
+        necessary_state_index = None
+
+        for index, (order, state_timestamp) in enumerate(sorted_states):
+            if necessary_state_index is None and state_timestamp > visualization_time:
+                necessary_state_index = index
+                break
+
+        if necessary_state_index is None:
+            # If the visualization time is after the last state then
+            # The last state is necessary
+            necessary_state_index = len(sorted_states) - 1
+        else:
+            # Else we need the state before the first state with greater timestamp
+            necessary_state_index -= 1
+
+        # Handle negative indexes
+        necessary_state_index = max(0, necessary_state_index)
+
+        state_orders_to_keep = []
+        missing_states = []
+        missing_updates = {}
+
+        last_state_index_in_client = -1
+        all_state_indexes_in_client = []
+
+        # We want to load the necessary state first, followed by
+        # the __MAX_STATES_IN_CLIENT_AFTER_NECESSARY next states and
+        # then the __MAX_STATES_IN_CLIENT_BEFORE_NECESSARY previous states
+        indexes_to_load = (
+            [necessary_state_index]
+            # + [
+            #     next_state_index
+            #     for next_state_index in range(
+            #         necessary_state_index + 1,
+            #         min(
+            #             necessary_state_index
+            #             + SimulationVisualizationDataManager.__MAX_STATES_IN_CLIENT_AFTER_NECESSARY
+            #             + 1,
+            #             len(sorted_states),
+            #         ),
+            #     )
+            # ]
+            # + [
+            #     previous_state_index
+            #     for previous_state_index in range(
+            #         necessary_state_index - 1,
+            #         max(
+            #             necessary_state_index
+            #             - SimulationVisualizationDataManager.__MAX_STATES_IN_CLIENT_BEFORE_NECESSARY
+            #             - 1,
+            #             -1,
+            #         ),
+            #         -1,
+            #     )
+            # ]
+            # All next states
+            + list(range(necessary_state_index + 1, len(sorted_states)))
+            # All previous states
+            + list(range(necessary_state_index - 1, -1, -1))
+        )
+
+        for index in indexes_to_load:
+            order, state_timestamp = sorted_states[index]
+
+            # If the client already has the state, skip it
+            # except the last state that might have changed
+            if order in loaded_state_orders and not order == max(loaded_state_orders):
+                state_orders_to_keep.append(order)
+
+                all_state_indexes_in_client.append(index)
+
+                last_state_index_in_client = max(last_state_index_in_client, index)
+
+                continue
+
+            # Don't add states if the max number of states is reached
+            # but continue the loop to know which states need to be kept
+            if len(missing_states) >= SimulationVisualizationDataManager.__MAX_STATES_AT_ONCE:
+                continue
+
+            state_file_path = SimulationVisualizationDataManager.get_saved_simulation_state_file_path(
+                simulation_id, order, state_timestamp
+            )
+
+            lock = FileLock(f"{state_file_path}.lock")
+
+            with lock:
+                with open(state_file_path, "r", encoding="utf-8") as file:
+                    environment_data = file.readline()
+                    missing_states.append(environment_data)
+
+                    updates_data = file.readlines()
+                    current_state_updates = []
+                    for update_data in updates_data:
+                        current_state_updates.append(update_data)
+
+                    missing_updates[order] = current_state_updates
+
+                    all_state_indexes_in_client.append(index)
+
+                    last_state_index_in_client = max(last_state_index_in_client, index)
+
+        client_has_last_state = last_state_index_in_client == len(sorted_states) - 1
+        client_has_max_states = len(missing_states) + len(state_orders_to_keep) >= len(indexes_to_load)
+
+        should_request_more_states = (is_simulation_complete and not client_has_max_states) or (
+            not is_simulation_complete and (client_has_last_state or not client_has_max_states)
+        )
+
+        first_continuous_state_index = necessary_state_index
+        last_continuous_state_index = necessary_state_index
+
+        all_state_indexes_in_client.sort()
+
+        necessary_state_index_index = all_state_indexes_in_client.index(necessary_state_index)
+
+        for index in range(necessary_state_index_index - 1, -1, -1):
+            if all_state_indexes_in_client[index] == first_continuous_state_index - 1:
+                first_continuous_state_index -= 1
+            else:
+                break
+
+        for index in range(necessary_state_index_index + 1, len(all_state_indexes_in_client)):
+            if all_state_indexes_in_client[index] == last_continuous_state_index + 1:
+                last_continuous_state_index += 1
+            else:
+                break
+
+        first_continuous_state_order = sorted_states[first_continuous_state_index][0]
+        last_continuous_state_order = sorted_states[last_continuous_state_index][0]
+
+        necessary_state_order = sorted_states[necessary_state_index][0]
+
+        return (
+            missing_states,
+            missing_updates,
+            state_orders_to_keep,
+            should_request_more_states,
+            first_continuous_state_order,
+            last_continuous_state_order,
+            necessary_state_order,
+        )
+
+    # MARK: +- Polylines
+
+    # The polylines are saved with the following structure :
+    # polylines/
+    #   version
+    #   polylines.jsonl
+    #     { "coordinatesString": "string", "encodedPolyline": "string", "coefficients": [float] }
+
+    @staticmethod
+    def get_saved_simulation_polylines_lock(simulation_id: str) -> FileLock:
+        simulation_directory_path = SimulationVisualizationDataManager.get_saved_simulation_directory_path(
+            simulation_id, True
+        )
+        return FileLock(f"{simulation_directory_path}/polylines.lock")
+
+    @staticmethod
+    def get_saved_simulation_polylines_directory_path(simulation_id: str) -> str:
+        simulation_directory_path = SimulationVisualizationDataManager.get_saved_simulation_directory_path(
+            simulation_id, True
+        )
+        directory_path = f"{simulation_directory_path}/{SimulationVisualizationDataManager.__POLYLINES_DIRECTORY_NAME}"
+
+        if not os.path.exists(directory_path):
+            os.makedirs(directory_path)
+
+        return directory_path
+
+    @staticmethod
+    def get_saved_simulation_polylines_version_file_path(simulation_id: str) -> str:
+        directory_path = SimulationVisualizationDataManager.get_saved_simulation_polylines_directory_path(simulation_id)
+        file_path = f"{directory_path}/{SimulationVisualizationDataManager.__POLYLINES_VERSION_FILE_NAME}"
+
+        if not os.path.exists(file_path):
+            with open(file_path, "w", encoding="utf-8") as file:
+                file.write(str(0))
+
+        return file_path
+
+    @staticmethod
+    def set_polylines_version(simulation_id: str, version: int) -> None:
+        """
+        Should always be called in a lock.
+        """
+        file_path = SimulationVisualizationDataManager.get_saved_simulation_polylines_version_file_path(simulation_id)
+
+        with open(file_path, "w", encoding="utf-8") as file:
+            file.write(str(version))
+
+    @staticmethod
+    def get_polylines_version(simulation_id: str) -> int:
+        """
+        Should always be called in a lock.
+        """
+        file_path = SimulationVisualizationDataManager.get_saved_simulation_polylines_version_file_path(simulation_id)
+
+        with open(file_path, "r", encoding="utf-8") as file:
+            return int(file.read())
+
+    @staticmethod
+    def get_polylines_version_with_lock(simulation_id: str) -> int:
+        lock = SimulationVisualizationDataManager.get_saved_simulation_polylines_lock(simulation_id)
+        with lock:
+            return SimulationVisualizationDataManager.get_polylines_version(simulation_id)
+
+    @staticmethod
+    def get_saved_simulation_polylines_file_path(simulation_id: str) -> str:
+        directory_path = SimulationVisualizationDataManager.get_saved_simulation_polylines_directory_path(simulation_id)
+
+        file_path = f"{directory_path}/{SimulationVisualizationDataManager.__POLYLINES_FILE_NAME}.jsonl"
+
+        if not os.path.exists(file_path):
+            with open(file_path, "w", encoding="utf-8") as file:
+                file.write("")
+
+        return file_path
+
+    @staticmethod
+    def set_polylines(simulation_id: str, polylines: dict[str, tuple[str, list[float]]]) -> None:
+
+        file_path = SimulationVisualizationDataManager.get_saved_simulation_polylines_file_path(simulation_id)
+
+        lock = SimulationVisualizationDataManager.get_saved_simulation_polylines_lock(simulation_id)
+
+        with lock:
+            # Increment the version to notify the client that the polylines have changed
+            version = SimulationVisualizationDataManager.get_polylines_version(simulation_id)
+            version += 1
+            SimulationVisualizationDataManager.set_polylines_version(simulation_id, version)
+
+            with open(file_path, "a", encoding="utf-8") as file:
+                for coordinates_string, (
+                    encoded_polyline,
+                    coefficients,
+                ) in polylines.items():
+                    data = {
+                        "coordinatesString": coordinates_string,
+                        "encodedPolyline": encoded_polyline,
+                        "coefficients": coefficients,
+                    }
+                    SimulationVisualizationDataManager.__format_json_one_line(data, file)
+
+    @staticmethod
+    def get_polylines(
+        simulation_id: str,
+    ) -> tuple[list[str], int]:
+
+        polylines = []
+
+        lock = SimulationVisualizationDataManager.get_saved_simulation_polylines_lock(simulation_id)
+
+        version = 0
+
+        with lock:
+            version = SimulationVisualizationDataManager.get_polylines_version(simulation_id)
+
+            file_path = SimulationVisualizationDataManager.get_saved_simulation_polylines_file_path(simulation_id)
+
+            with open(file_path, "r", encoding="utf-8") as file:
+                for line in file:
+                    polylines.append(line)
+
+        return polylines, version