ferrostar 0.51.0

use std::sync::Arc;

use super::{StepAdvanceCondition, StepAdvanceConditionSerializable, StepAdvanceResult};
use crate::{
    algorithms::{
        deviation_from_line, get_linestring, is_within_threshold_to_end_of_linestring,
        snap_user_location_to_line,
    },
    navigation_controller::models::TripState,
};
use geo::Point;
use serde::{Deserialize, Serialize};

#[cfg(feature = "wasm-bindgen")]
use tsify::Tsify;

#[cfg(test)]
use proptest::prelude::*;

#[cfg(test)]
use crate::{
    deviation_detection::{DeviationKind, RouteDeviation},
    navigation_controller::test_helpers::get_navigating_trip_state,
    test_utils::{arb_coord, make_user_location},
};

use super::SerializableStepAdvanceCondition;

/// Never advances to the next step automatically;
/// requires calling [`NavigationController::advance_to_next_step`](super::NavigationController::advance_to_next_step).
///
/// You can use this to implement custom behaviors in external code.
#[derive(Debug, Copy, Clone)]
#[cfg_attr(feature = "uniffi", derive(uniffi::Object))]
pub struct ManualStepCondition;

impl StepAdvanceCondition for ManualStepCondition {
    #[allow(unused_variables)]
    fn should_advance_step(&self, trip_state: TripState) -> StepAdvanceResult {
        StepAdvanceResult::continue_with_state(Arc::new(ManualStepCondition))
    }

    fn new_instance(&self) -> Arc<dyn StepAdvanceCondition> {
        Arc::new(ManualStepCondition)
    }
}

impl StepAdvanceConditionSerializable for ManualStepCondition {
    fn to_js(&self) -> SerializableStepAdvanceCondition {
        SerializableStepAdvanceCondition::Manual
    }
}

// MARK: Basic Conditions

/// Automatically advances when the user's location is close enough to the end of the step.
///
/// This results in an eager advance where the user will jump to the next step when the
/// condition is met.
#[derive(Debug, Copy, Clone)]
#[cfg_attr(feature = "uniffi", derive(uniffi::Object))]
pub struct DistanceToEndOfStepCondition {
    /// Distance to the last waypoint in the step, measured in meters, at which to advance.
    pub distance: u16,
    /// The minimum required horizontal accuracy of the user location, in meters.
    /// Values larger than this cannot trigger a step advance.
    pub minimum_horizontal_accuracy: u16,
}

impl StepAdvanceCondition for DistanceToEndOfStepCondition {
    fn should_advance_step(&self, trip_state: TripState) -> StepAdvanceResult {
        self.should_advance_inner(&trip_state)
            .unwrap_or(StepAdvanceResult::continue_with_state(self.new_instance()))
    }

    fn new_instance(&self) -> Arc<dyn StepAdvanceCondition> {
        Arc::new(DistanceToEndOfStepCondition {
            distance: self.distance,
            minimum_horizontal_accuracy: self.minimum_horizontal_accuracy,
        })
    }
}

impl DistanceToEndOfStepCondition {
    fn should_advance_inner(&self, trip_state: &TripState) -> Option<StepAdvanceResult> {
        let user_location = trip_state.user_location()?;
        let current_step = trip_state.current_step()?;

        let should_advance =
            if user_location.horizontal_accuracy > self.minimum_horizontal_accuracy.into() {
                false
            } else {
                is_within_threshold_to_end_of_linestring(
                    &user_location.into(),
                    &current_step.get_linestring(),
                    f64::from(self.distance),
                )
            };

        let result = if should_advance {
            StepAdvanceResult::advance_to_new_instance(self)
        } else {
            StepAdvanceResult::continue_with_state(self.new_instance())
        };

        Some(result)
    }
}

impl StepAdvanceConditionSerializable for DistanceToEndOfStepCondition {
    fn to_js(&self) -> SerializableStepAdvanceCondition {
        SerializableStepAdvanceCondition::DistanceToEndOfStep {
            distance: self.distance,
            minimum_horizontal_accuracy: self.minimum_horizontal_accuracy,
        }
    }
}

/// Controls when a deviation-aware step-advance condition is allowed to evaluate,
/// based on the user's current
/// [`RouteDeviation`](crate::deviation_detection::RouteDeviation) status.
#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
#[cfg_attr(feature = "wasm-bindgen", derive(Tsify))]
#[cfg_attr(feature = "wasm-bindgen", tsify(into_wasm_abi, from_wasm_abi))]
pub enum DeviationCalculationPolicy {
    /// Always evaluate, regardless of deviation status.
    Always,
    /// Evaluate while the user is still somewhere on the route polyline
    /// (current step or any future step),
    /// but suspend if the user is completely off the route.
    WhileOnRoute,
    /// Evaluate only while the user is within an acceptable deviation of the current step's polyline.
    ///
    /// Suspend on any deviation
    /// (whether off-step-but-on-route, or completely off-route).
    WhileOnCurrentStep,
}

/// Advances once the user is at least [`Self::distance`] meters from the current step's polyline.
///
/// This results in *delayed* advance,
/// but is more robust to spurious / unwanted step changes in scenarios including
/// self-intersecting routes (sudden jumps to the next step)
/// and pauses at intersections (advancing too soon before the maneuver is complete).
///
/// NOTE! This may be less robust to things like short steps, out-and-backs, and U-turns,
/// where this may eagerly exit a current step before the user has traversed it
/// if the start of the step is within range of the end.
#[derive(Debug, Copy, Clone)]
#[cfg_attr(feature = "uniffi", derive(uniffi::Object))]
pub struct DistanceFromStepCondition {
    /// The minimum distance, in meters,
    /// from the current step's polyline at which this condition advances.
    pub distance: u16,
    /// The minimum required horizontal accuracy of the user location, in meters.
    /// Locations with reported accuracy worse than this cannot trigger a step advance.
    pub minimum_horizontal_accuracy: u16,
    /// Controls when this condition is permitted to evaluate based on the user's current
    /// [`RouteDeviation`](crate::deviation_detection::RouteDeviation) status.
    pub calculation_policy: DeviationCalculationPolicy,
}

impl StepAdvanceCondition for DistanceFromStepCondition {
    fn should_advance_step(&self, trip_state: TripState) -> StepAdvanceResult {
        self.should_advance_inner(&trip_state)
            .unwrap_or(StepAdvanceResult::continue_with_state(self.new_instance()))
    }

    fn new_instance(&self) -> Arc<dyn StepAdvanceCondition> {
        // Simple Arc::new here; there is no internal state to reset for this condition.
        Arc::new(*self)
    }
}

impl DistanceFromStepCondition {
    fn should_advance_inner(&self, trip_state: &TripState) -> Option<StepAdvanceResult> {
        let deviation = trip_state.deviation()?;
        let user_location = trip_state.user_location()?;
        let current_step = trip_state.current_step()?;

        let permits_calculation = match self.calculation_policy {
            DeviationCalculationPolicy::Always => true,
            DeviationCalculationPolicy::WhileOnRoute => !deviation.is_completely_off_route(),
            DeviationCalculationPolicy::WhileOnCurrentStep => {
                !deviation.is_deviated_from_current_step()
            }
        };
        let location_too_inaccurate =
            user_location.horizontal_accuracy > self.minimum_horizontal_accuracy.into();

        let should_advance = if !permits_calculation || location_too_inaccurate {
            // Bail early
            false
        } else {
            let current_position: Point = user_location.into();
            let current_step_linestring = current_step.get_linestring();

            deviation_from_line(&current_position, &current_step_linestring)
                .is_some_and(|deviation| deviation > self.distance.into())
        };

        let result = if should_advance {
            StepAdvanceResult::advance_to_new_instance(self)
        } else {
            StepAdvanceResult::continue_with_state(self.new_instance())
        };

        Some(result)
    }
}

impl StepAdvanceConditionSerializable for DistanceFromStepCondition {
    fn to_js(&self) -> SerializableStepAdvanceCondition {
        SerializableStepAdvanceCondition::DistanceFromStep {
            distance: self.distance,
            minimum_horizontal_accuracy: self.minimum_horizontal_accuracy,
            calculation_policy: self.calculation_policy,
        }
    }
}

/// Advance if any of the conditions are met (OR).
///
/// This is ideal for short circuit type advance conditions.
///
/// E.g. you may have:
/// 1. A short circuit detecting if the user has exceeded a large distance from the current step.
/// 2. A default advance behavior.
#[derive(Clone)]
#[cfg_attr(feature = "uniffi", derive(uniffi::Object))]
pub struct OrAdvanceConditions {
    pub conditions: Vec<Arc<dyn StepAdvanceCondition>>,
}

impl StepAdvanceCondition for OrAdvanceConditions {
    fn should_advance_step(&self, trip_state: TripState) -> StepAdvanceResult {
        let mut should_advance = false;
        let mut next_conditions = Vec::with_capacity(self.conditions.len());

        for condition in &self.conditions {
            let result = condition.should_advance_step(trip_state.clone());
            should_advance = should_advance || result.should_advance;
            next_conditions.push(result.next_iteration);
        }

        StepAdvanceResult {
            should_advance,
            next_iteration: if should_advance {
                // When advancing, create fresh instances of all conditions to ensure state isolation
                self.new_instance()
            } else {
                // Preserve stateful progress when not advancing
                Arc::new(OrAdvanceConditions {
                    conditions: next_conditions,
                })
            },
        }
    }

    fn new_instance(&self) -> Arc<dyn StepAdvanceCondition> {
        Arc::new(OrAdvanceConditions {
            conditions: self
                .conditions
                .iter()
                .map(|condition| condition.new_instance())
                .collect(),
        })
    }
}

impl StepAdvanceConditionSerializable for OrAdvanceConditions {
    fn to_js(&self) -> SerializableStepAdvanceCondition {
        SerializableStepAdvanceCondition::OrAdvanceConditions {
            conditions: self.conditions.iter().map(|c| c.to_js()).collect(),
        }
    }
}

/// Advance if all of the conditions are met (AND).
#[derive(Clone)]
#[cfg_attr(feature = "uniffi", derive(uniffi::Object))]
pub struct AndAdvanceConditions {
    pub conditions: Vec<Arc<dyn StepAdvanceCondition>>,
}

impl StepAdvanceCondition for AndAdvanceConditions {
    fn should_advance_step(&self, trip_state: TripState) -> StepAdvanceResult {
        let mut should_advance = true;
        let mut next_conditions = Vec::with_capacity(self.conditions.len());

        for condition in &self.conditions {
            let result = condition.should_advance_step(trip_state.clone());
            should_advance = should_advance && result.should_advance;
            next_conditions.push(result.next_iteration);
        }

        StepAdvanceResult {
            should_advance,
            next_iteration: if should_advance {
                // When advancing, create fresh instances of all conditions to ensure state isolation
                self.new_instance()
            } else {
                // Preserve stateful progress when not advancing
                Arc::new(AndAdvanceConditions {
                    conditions: next_conditions,
                })
            },
        }
    }

    fn new_instance(&self) -> Arc<dyn StepAdvanceCondition> {
        Arc::new(AndAdvanceConditions {
            conditions: self
                .conditions
                .iter()
                .map(|condition| condition.new_instance())
                .collect(),
        })
    }
}

impl StepAdvanceConditionSerializable for AndAdvanceConditions {
    fn to_js(&self) -> SerializableStepAdvanceCondition {
        SerializableStepAdvanceCondition::AndAdvanceConditions {
            conditions: self.conditions.iter().map(|c| c.to_js()).collect(),
        }
    }
}

/// A stateful condition that requires the user to reach the end of the step then proceed past it to advance.
#[derive(Debug, Copy, Clone)]
#[cfg_attr(feature = "uniffi", derive(uniffi::Object))]
pub struct DistanceEntryAndExitCondition {
    /// Mark the arrival at the end of the step once the user is within this distance.
    pub(super) distance_to_end_of_step: u16,
    /// Advance only after the user has left the end of the step by at least this distance.
    ///
    /// This value should be small to avoid the user appearing stuck on the step when using
    /// visible location snapping.
    pub(super) distance_after_end_of_step: u16,
    /// The minimum required horizontal accuracy of the user location, in meters.
    /// Values larger than this cannot ever trigger a step advance.
    pub(super) minimum_horizontal_accuracy: u16,
    /// Internal state for tracking when the user is within `distance_to_end_of_step` meters from the end of the step.
    /// This allows for stateful advance only after entering a reasonable radius of the goal
    /// and then exiting the area by a separate trigger threshold.
    pub(super) has_reached_end_of_current_step: bool,
    // TODO: Do we want a speed multiplier
}

impl Default for DistanceEntryAndExitCondition {
    fn default() -> Self {
        Self {
            distance_to_end_of_step: 20,
            distance_after_end_of_step: 5,
            minimum_horizontal_accuracy: 25,
            has_reached_end_of_current_step: false,
        }
    }
}

#[cfg(test)]
impl DistanceEntryAndExitCondition {
    pub fn exact() -> Self {
        Self {
            distance_to_end_of_step: 0,
            distance_after_end_of_step: 0,
            minimum_horizontal_accuracy: 0,
            has_reached_end_of_current_step: false,
        }
    }
}

impl StepAdvanceCondition for DistanceEntryAndExitCondition {
    fn should_advance_step(&self, trip_state: TripState) -> StepAdvanceResult {
        if self.has_reached_end_of_current_step {
            // This inner check fires once the user is far enough from the current step's
            // polyline that we treat them as having moved past the end of the step.
            //
            // `WhileOnRoute` is the policy we want here:
            //   - On `OffStepOnRoute` (user has progressed onto a future step):
            //     evaluate. That is the normal success case for an exit check.
            //   - On `CompletelyOffRoute` (user is lost): suspend.
            //     The rerouter, not this condition, should drive what happens next.
            let distance_from_end = DistanceFromStepCondition {
                minimum_horizontal_accuracy: self.minimum_horizontal_accuracy,
                distance: self.distance_after_end_of_step,
                calculation_policy: DeviationCalculationPolicy::WhileOnRoute,
            };

            let should_advance = distance_from_end
                .should_advance_step(trip_state)
                .should_advance;

            if should_advance {
                StepAdvanceResult::advance_to_new_instance(self)
            } else {
                // The condition was not advanced. So we return a fresh iteration
                // where has_reached_end_of_current_step is still true to re-trigger this part 2 logic.
                StepAdvanceResult::continue_with_state(Arc::new(DistanceEntryAndExitCondition {
                    distance_to_end_of_step: self.distance_to_end_of_step,
                    distance_after_end_of_step: self.distance_after_end_of_step,
                    minimum_horizontal_accuracy: self.minimum_horizontal_accuracy,
                    has_reached_end_of_current_step: true,
                }))
            }
        } else {
            let distance_to_end = DistanceToEndOfStepCondition {
                minimum_horizontal_accuracy: self.minimum_horizontal_accuracy,
                distance: self.distance_to_end_of_step,
            };

            // Use the distance to end to determine if has_reached_end_of_current_step
            let next_iteration = DistanceEntryAndExitCondition {
                minimum_horizontal_accuracy: self.minimum_horizontal_accuracy,
                distance_to_end_of_step: self.distance_to_end_of_step,
                distance_after_end_of_step: self.distance_after_end_of_step,
                has_reached_end_of_current_step: distance_to_end
                    .should_advance_step(trip_state)
                    .should_advance,
            };

            StepAdvanceResult::continue_with_state(Arc::new(next_iteration))
        }
    }

    fn new_instance(&self) -> Arc<dyn StepAdvanceCondition> {
        Arc::new(DistanceEntryAndExitCondition {
            distance_to_end_of_step: self.distance_to_end_of_step,
            distance_after_end_of_step: self.distance_after_end_of_step,
            minimum_horizontal_accuracy: self.minimum_horizontal_accuracy,
            has_reached_end_of_current_step: false, // Always reset to initial state
        })
    }
}

impl StepAdvanceConditionSerializable for DistanceEntryAndExitCondition {
    fn to_js(&self) -> SerializableStepAdvanceCondition {
        SerializableStepAdvanceCondition::DistanceEntryExit {
            minimum_horizontal_accuracy: self.minimum_horizontal_accuracy,
            distance_to_end_of_step: self.distance_to_end_of_step,
            distance_after_end_step: self.distance_after_end_of_step,
            has_reached_end_of_current_step: self.has_reached_end_of_current_step,
        }
    }
}

/// A stateful condition that requires the user to reach the end of the step then proceed past it to advance.
///
/// This variant uses route snapping (snapping to the combined current+next step geometry) for the exit check,
/// making it more robust for pedestrian/hiking navigation where users may walk on the opposite side of the street
/// or wander around the optimal path. The route-snapped exit check prevents premature advancement while still
/// allowing natural pedestrian movement patterns.
/// The exit distance is measured from the current step to the route-snapped position.
#[derive(Debug, Copy, Clone)]
#[cfg_attr(feature = "uniffi", derive(uniffi::Object))]
pub struct DistanceEntryAndSnappedExitCondition {
    /// Mark the arrival at the end of the step once the user is within this distance.
    pub(super) distance_to_end_of_step: u16,
    /// Advance only after the route-snapped position has moved this distance from the current step.
    ///
    /// This uses a snapped position to the combined route (current+next steps) which provides
    /// better handling of pedestrian scenarios like walking on the opposite side of the street.
    /// Values of 2-5m work well for pedestrian navigation.
    pub(super) distance_after_end_of_step: u16,
    /// The minimum required horizontal accuracy of the user location, in meters.
    /// Values larger than this cannot ever trigger a step advance.
    pub(super) minimum_horizontal_accuracy: u16,
    /// Internal state for tracking when the user is within `distance_to_end_of_step` meters from the end of the step.
    pub(super) has_reached_end_of_current_step: bool,
}

impl Default for DistanceEntryAndSnappedExitCondition {
    fn default() -> Self {
        Self {
            distance_to_end_of_step: 20,
            distance_after_end_of_step: 2,
            minimum_horizontal_accuracy: 25,
            has_reached_end_of_current_step: false,
        }
    }
}

#[cfg(test)]
impl DistanceEntryAndSnappedExitCondition {
    pub fn exact() -> Self {
        Self {
            distance_to_end_of_step: 0,
            distance_after_end_of_step: 0,
            minimum_horizontal_accuracy: 0,
            has_reached_end_of_current_step: false,
        }
    }
}

impl StepAdvanceCondition for DistanceEntryAndSnappedExitCondition {
    #[allow(unused_variables)]
    fn should_advance_step(&self, trip_state: TripState) -> StepAdvanceResult {
        let result = if self.has_reached_end_of_current_step {
            // EXIT CHECK: Use existing distance to end logic
            self.check_exit_result(&trip_state)
        } else {
            // ENTRY CHECK: Use existing distance to end logic
            self.check_entry_result(&trip_state)
        };

        result.unwrap_or(StepAdvanceResult::continue_with_state(self.new_instance()))
    }

    fn new_instance(&self) -> Arc<dyn StepAdvanceCondition> {
        Arc::new(DistanceEntryAndSnappedExitCondition {
            has_reached_end_of_current_step: false, // Always reset this to the initial state
            ..*self
        })
    }
}

impl DistanceEntryAndSnappedExitCondition {
    fn check_exit_result(&self, trip_state: &TripState) -> Option<StepAdvanceResult> {
        let user_location = trip_state.user_location()?;
        let current_step = trip_state.current_step()?;
        let next_step = trip_state.next_step();

        let should_advance = if user_location.horizontal_accuracy
            > self.minimum_horizontal_accuracy.into()
        {
            false
        } else if let Some(next) = next_step {
            // Build combined linestring from current + N next steps
            // Accumulate steps until we have enough distance for meaningful exit check
            let mut combined_coords = current_step.geometry.clone();
            let mut accumulated_distance = next.distance;
            let mut step_index = 1;

            // Add first next step
            combined_coords.extend(next.geometry.clone());

            // Keep adding subsequent steps until we have sufficient distance
            // or run out of steps. Use 2x multiplier to increase chances of handling
            // U-turns and complex geometries in future steps.
            let target_distance = (self.distance_after_end_of_step as f64) * 2.0;
            while accumulated_distance < target_distance {
                if let Some(future_step) = trip_state.get_step(step_index + 1) {
                    combined_coords.extend(future_step.geometry.clone());
                    accumulated_distance += future_step.distance;
                    step_index += 1;
                } else {
                    break;
                }
            }

            let combined_linestring = get_linestring(&combined_coords);

            // Snap to the combined route
            let snapped_to_route = snap_user_location_to_line(user_location, &combined_linestring);

            // Measure distance from CURRENT step only
            let current_step_linestring = current_step.get_linestring();
            let deviation =
                deviation_from_line(&Point::from(snapped_to_route), &current_step_linestring)
                    .unwrap_or(0.0);

            // Use the minimum of configured exit distance and accumulated distance
            // to handle cases where there aren't enough future steps
            let effective_exit_distance =
                (self.distance_after_end_of_step as f64).min(accumulated_distance);

            deviation >= effective_exit_distance
        } else {
            // Advance because no next step.
            true
        };

        // EXIT CHECK: Use route-snapped position
        if should_advance {
            Some(StepAdvanceResult::advance_to_new_instance(self))
        } else {
            None
        }
    }

    fn check_entry_result(&self, trip_state: &TripState) -> Option<StepAdvanceResult> {
        let distance_to_end = DistanceToEndOfStepCondition {
            minimum_horizontal_accuracy: self.minimum_horizontal_accuracy,
            distance: self.distance_to_end_of_step,
        };

        let next_iteration = DistanceEntryAndSnappedExitCondition {
            has_reached_end_of_current_step: distance_to_end
                .should_advance_step(trip_state.clone())
                .should_advance,
            ..*self
        };

        let result = StepAdvanceResult::continue_with_state(Arc::new(next_iteration));
        Some(result)
    }
}

impl StepAdvanceConditionSerializable for DistanceEntryAndSnappedExitCondition {
    fn to_js(&self) -> SerializableStepAdvanceCondition {
        SerializableStepAdvanceCondition::DistanceEntryAndSnappedExit {
            minimum_horizontal_accuracy: self.minimum_horizontal_accuracy,
            distance_to_end_of_step: self.distance_to_end_of_step,
            distance_after_end_step: self.distance_after_end_of_step,
            has_reached_end_of_current_step: self.has_reached_end_of_current_step,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::models::{RouteStep, UserLocation};
    use crate::navigation_controller::test_helpers::{
        gen_route_step_with_coords, get_navigating_trip_state,
    };
    use crate::test_utils::make_user_location;
    use geo::coord;
    use std::sync::LazyLock;

    static STRAIGHT_LINE_SHORT_ROUTE_STEP: LazyLock<RouteStep> = LazyLock::new(|| {
        gen_route_step_with_coords(vec![
            coord!(x: 0.0, y: 0.0),   // Origin
            coord!(x: 0.001, y: 0.0), // 111 meters east at the equator
        ])
    });

    static LOCATION_NEAR_START_OF_STEP: LazyLock<UserLocation> =
        LazyLock::new(|| make_user_location(coord!(x: 0.0001, y: 0.0), 5.0));
    static LOCATION_NEAR_END_OF_STEP: LazyLock<UserLocation> =
        LazyLock::new(|| make_user_location(coord!(x: 0.00099, y: 0.0), 5.0));

    #[test]
    fn test_manual_step_advance() {
        let condition = ManualStepCondition;

        let trip_state = get_navigating_trip_state(
            *LOCATION_NEAR_START_OF_STEP,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // Test the condition - we should NOT advance since we're far from the end
        let result = condition.should_advance_step(trip_state);

        // We should never advance to the next step in manual mode,
        // so the list should always be empty.
        assert!(
            !result.should_advance,
            "Should not advance with the manual condition"
        );
    }

    #[test]
    fn test_distance_to_end_of_step_doesnt_advance() {
        // Set up the condition with a distance threshold of 20 meters
        let condition = DistanceToEndOfStepCondition {
            minimum_horizontal_accuracy: 10,
            distance: 20, // Must be within 20 meters of the end to advance
        };

        let trip_state = get_navigating_trip_state(
            *LOCATION_NEAR_START_OF_STEP,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // Test the condition - we should NOT advance since we're far from the end
        let result = condition.should_advance_step(trip_state);

        assert!(
            !result.should_advance,
            "Should not advance when far from the end of the step"
        );
    }

    #[test]
    fn test_distance_to_end_of_step_advance() {
        // Set up the condition with a distance threshold of 20 meters
        let condition = DistanceToEndOfStepCondition {
            minimum_horizontal_accuracy: 10,
            distance: 20, // Must be within 20 meters of the end to advance
        };

        let trip_state = get_navigating_trip_state(
            *LOCATION_NEAR_END_OF_STEP,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // Test the condition - we SHOULD advance since we're close to the end
        let result = condition.should_advance_step(trip_state);

        assert!(
            result.should_advance,
            "Should advance when close to the end of the step"
        );
    }

    #[test]
    fn test_distance_from_step_advance_with_deviation() {
        // Create a location that's far from the route (500+ meters north)
        // At the equator, 0.005° latitude is approximately 555 meters
        let user_location = make_user_location(coord!(x: 0.005, y: 0.0005), 5.0);

        // Set up the condition with a minimum deviation of 100 meters to advance
        let condition = DistanceFromStepCondition {
            minimum_horizontal_accuracy: 10,
            distance: 100, // Must be at least 100 meters from route to advance
            calculation_policy: DeviationCalculationPolicy::Always,
        };

        let trip_state = get_navigating_trip_state(
            user_location,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::Deviation {
                kind: DeviationKind::CompletelyOffRoute {
                    deviation_from_route_line: 10.0,
                },
            },
        );

        // Test the condition - we SHOULD advance since we're far from the route
        let result = condition.should_advance_step(trip_state);

        assert!(
            result.should_advance,
            "Should advance when far from the route"
        );
    }

    #[test]
    fn test_distance_from_step_no_advance_when_completely_off_route() {
        // Create a location that's far from the route (500+ meters north)
        // At the equator, 0.005° latitude is approximately 555 meters
        let user_location = make_user_location(coord!(x: 0.005, y: 0.0005), 5.0);

        // Set up the condition with a minimum deviation of 100 meters to advance
        let condition = DistanceFromStepCondition {
            minimum_horizontal_accuracy: 10,
            distance: 100, // Must be at least 100 meters from route to advance
            calculation_policy: DeviationCalculationPolicy::WhileOnRoute,
        };

        let trip_state = get_navigating_trip_state(
            user_location,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::Deviation {
                kind: DeviationKind::CompletelyOffRoute {
                    deviation_from_route_line: 10.0,
                },
            },
        );

        // Test the condition - we SHOULD advance since we're far from the route
        let result = condition.should_advance_step(trip_state);

        assert!(
            !result.should_advance,
            "WhileOnRoute should not advance when the user is completely off the route"
        );
    }

    #[test]
    fn test_distance_from_step_advance() {
        // Create a location that's far from the route (500+ meters north)
        // At the equator, 0.005° latitude is approximately 555 meters
        let user_location = make_user_location(coord!(x: 0.005, y: 0.0005), 5.0);

        // Set up the condition with a minimum deviation of 100 meters to advance
        let condition = DistanceFromStepCondition {
            minimum_horizontal_accuracy: 10,
            distance: 100, // Must be at least 100 meters from route to advance
            calculation_policy: DeviationCalculationPolicy::WhileOnRoute,
        };

        let trip_state = get_navigating_trip_state(
            user_location,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // Test the condition - we SHOULD advance since we're far from the route
        let result = condition.should_advance_step(trip_state);

        assert!(
            result.should_advance,
            "Should advance when far from the route"
        );
    }

    // Combination Rules

    #[test]
    fn test_or_condition_doesnt_advance() {
        // Create two false conditions - both manual step advance
        let manual_condition1 = ManualStepCondition;
        let manual_condition2 = ManualStepCondition;

        // Create an OR condition - should only advance when at least one condition is true
        let or_condition = OrAdvanceConditions {
            conditions: vec![Arc::new(manual_condition1), Arc::new(manual_condition2)],
        };

        let trip_state = get_navigating_trip_state(
            *LOCATION_NEAR_START_OF_STEP,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // Test the condition - we should NOT advance since both conditions are false
        let result = or_condition.should_advance_step(trip_state);

        assert!(
            !result.should_advance,
            "Should not advance when all OR conditions are false"
        );
    }

    #[test]
    fn test_or_condition_advance() {
        // Create a false condition
        let manual_condition = ManualStepCondition;

        // Create a true condition - distance to end of step
        let distance_condition = DistanceToEndOfStepCondition {
            minimum_horizontal_accuracy: 10,
            distance: 20, // Must be within 20 meters of the end to advance
        };

        // Create an OR condition - should advance when any condition is true
        let or_condition = OrAdvanceConditions {
            conditions: vec![Arc::new(manual_condition), Arc::new(distance_condition)],
        };

        let trip_state = get_navigating_trip_state(
            *LOCATION_NEAR_END_OF_STEP,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // Test the condition - we SHOULD advance since one condition is true
        let result = or_condition.should_advance_step(trip_state);

        assert!(
            result.should_advance,
            "Should advance when at least one OR condition is true"
        );
    }

    #[test]
    fn test_and_condition_doesnt_advance() {
        // Create a false condition
        let manual_condition = ManualStepCondition;

        // Create a true condition - distance to end of step
        let distance_condition = DistanceToEndOfStepCondition {
            minimum_horizontal_accuracy: 10,
            distance: 20, // Must be within 20 meters of the end to advance
        };

        // Create an AND condition - should only advance when all conditions are true
        let and_condition = AndAdvanceConditions {
            conditions: vec![
                Arc::new(manual_condition),   // This will always be false
                Arc::new(distance_condition), // This will be true
            ],
        };

        let trip_state = get_navigating_trip_state(
            *LOCATION_NEAR_END_OF_STEP,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // Test the condition - we should NOT advance since one condition is false
        let result = and_condition.should_advance_step(trip_state);

        assert!(
            !result.should_advance,
            "Should not advance when at least one AND condition is false"
        );
    }

    #[test]
    fn test_and_condition_advance() {
        // Create two true conditions - both distance to end of step but with different thresholds
        let distance_condition1 = DistanceToEndOfStepCondition {
            minimum_horizontal_accuracy: 10,
            distance: 30, // Must be within 30 meters of the end to advance
        };

        let distance_condition2 = DistanceToEndOfStepCondition {
            minimum_horizontal_accuracy: 10,
            distance: 20, // Must be within 20 meters of the end to advance
        };

        // Create an AND condition - should only advance when all conditions are true
        let and_condition = AndAdvanceConditions {
            conditions: vec![Arc::new(distance_condition1), Arc::new(distance_condition2)],
        };

        let trip_state = get_navigating_trip_state(
            *LOCATION_NEAR_END_OF_STEP,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // Test the condition - we SHOULD advance since both conditions are true
        let result = and_condition.should_advance_step(trip_state);

        assert!(
            result.should_advance,
            "Should advance when all AND conditions are true"
        );
    }

    // Stateful Conditions

    #[test]
    fn test_entry_and_exit_condition_doesnt_advance() {
        // Create a condition that requires proximity to end followed by distance from step
        let condition = DistanceEntryAndExitCondition {
            distance_to_end_of_step: 10,
            distance_after_end_of_step: 20,
            minimum_horizontal_accuracy: 5,
            has_reached_end_of_current_step: false,
        };

        let trip_state = get_navigating_trip_state(
            *LOCATION_NEAR_END_OF_STEP,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // First update: User is close to the end of the step...
        // Should not advance yet, but should update internal state
        let result1 = condition.should_advance_step(trip_state);

        assert!(
            !result1.should_advance,
            "Should not advance on first update even when near end of step"
        );

        // Second update: User has moved but is still too close to the route
        // This is only 2 meters from the end point, not the required 5 meters
        let user_location_still_close = make_user_location(coord!(x: 0.001, y: 0.00002), 5.0);

        // Get the next iteration from the first result
        let next_condition = result1.next_iteration;

        let trip_state2 = get_navigating_trip_state(
            user_location_still_close,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // Should still not advance because we haven't moved far enough away
        let result2 = next_condition.should_advance_step(trip_state2);

        assert!(
            !result2.should_advance,
            "Should not advance when user hasn't moved far enough from the route"
        );
    }

    #[test]
    fn test_entry_and_exit_condition_advance() {
        // Create a condition that requires proximity to end followed by distance from step
        let condition = DistanceEntryAndExitCondition {
            distance_to_end_of_step: 10,
            distance_after_end_of_step: 20,
            minimum_horizontal_accuracy: 5,
            has_reached_end_of_current_step: false,
        };

        let trip_state = get_navigating_trip_state(
            *LOCATION_NEAR_END_OF_STEP,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // First update: User is close to the end of the step...
        // Should not advance yet, but should update internal state
        let result1 = condition.should_advance_step(trip_state);

        assert!(
            !result1.should_advance,
            "Should not advance on first update even when near end of step"
        );

        // Get the next iteration with updated internal state
        let next_condition = result1.next_iteration;

        // Second update: User has moved far enough from the route (> 5 meters)
        // ~55 meters north of the route (0.0005 degrees latitude)
        let user_location_far = make_user_location(coord!(x: 0.001, y: 0.0005), 5.0);

        let trip_state2 = get_navigating_trip_state(
            user_location_far,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // Now should advance because we've satisfied both conditions sequentially
        let result2 = next_condition.should_advance_step(trip_state2);

        assert!(
            result2.should_advance,
            "Should advance when user has first reached end of step and then moved away"
        );
    }

    #[test]
    fn test_and_condition_preserves_state() {
        // Create a stateful condition that we can track
        let entry_exit_condition = DistanceEntryAndExitCondition {
            distance_to_end_of_step: 10,
            distance_after_end_of_step: 5,
            minimum_horizontal_accuracy: 5,
            has_reached_end_of_current_step: false,
        };

        // Create an AND condition with just this one condition for simplicity
        let and_condition = AndAdvanceConditions {
            conditions: vec![Arc::new(entry_exit_condition)],
        };

        let trip_state = get_navigating_trip_state(
            *LOCATION_NEAR_END_OF_STEP,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // First update: User is close to the end of the step
        let result1 = and_condition.should_advance_step(trip_state);

        assert!(
            !result1.should_advance,
            "Should not advance on first update"
        );

        // Get the next iteration and cast it back to check the internal state
        let next_and_condition = result1.next_iteration;

        // Second update: User moves far away - should advance now
        let user_location_far = make_user_location(coord!(x: 0.001, y: 0.0005), 5.0);

        let trip_state2 = get_navigating_trip_state(
            user_location_far,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        let result2 = next_and_condition.should_advance_step(trip_state2);

        assert!(
            result2.should_advance,
            "Should advance when stateful condition completes in AND"
        );
    }

    #[test]
    fn test_entry_and_exit_condition_in_and_composite_advance() {
        // Create a condition that requires proximity to end followed by distance from step
        let entry_exit_condition = DistanceEntryAndExitCondition {
            distance_to_end_of_step: 10,
            distance_after_end_of_step: 5,
            minimum_horizontal_accuracy: 5,
            has_reached_end_of_current_step: false,
        };

        // Create a simple condition that's always true when near the end
        let distance_condition = DistanceToEndOfStepCondition {
            minimum_horizontal_accuracy: 10,
            distance: 100, // Increased to 100 meters to account for the test location
        };

        // Create an AND condition combining both
        let and_condition = AndAdvanceConditions {
            conditions: vec![Arc::new(entry_exit_condition), Arc::new(distance_condition)],
        };

        let trip_state = get_navigating_trip_state(
            *LOCATION_NEAR_END_OF_STEP,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // First update: User is close to the end of the step
        // Should not advance yet, but should update internal state of the entry/exit condition
        let result1 = and_condition.should_advance_step(trip_state);

        assert!(
            !result1.should_advance,
            "Should not advance on first update even when near end of step"
        );

        // Get the next iteration with updated internal state
        let next_condition = result1.next_iteration;

        // Second update: User has moved far enough from the route (> 20 meters)
        // ~55 meters north of the route (0.0005 degrees latitude)
        let user_location_far = make_user_location(coord!(x: 0.001, y: 0.0005), 5.0);

        let trip_state2 = get_navigating_trip_state(
            user_location_far,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // Now should advance because the entry/exit condition has maintained its state
        // through the AND composite condition
        let result2 = next_condition.should_advance_step(trip_state2);

        assert!(
            result2.should_advance,
            "Should advance when stateful condition completes within AND composite"
        );
    }

    #[test]
    fn test_entry_and_exit_condition_in_or_composite_advance() {
        // Create a condition that requires proximity to end followed by distance from step
        let entry_exit_condition = DistanceEntryAndExitCondition {
            distance_to_end_of_step: 10,
            distance_after_end_of_step: 5,
            minimum_horizontal_accuracy: 5,
            has_reached_end_of_current_step: false,
        };

        // Create a condition that will never be true (manual)
        let manual_condition = ManualStepCondition;

        // Create an OR condition combining both
        let or_condition = OrAdvanceConditions {
            conditions: vec![Arc::new(entry_exit_condition), Arc::new(manual_condition)],
        };

        let trip_state = get_navigating_trip_state(
            *LOCATION_NEAR_END_OF_STEP,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // First update: User is close to the end of the step
        // Should not advance yet, but should update internal state of the entry/exit condition
        let result1 = or_condition.should_advance_step(trip_state);

        assert!(
            !result1.should_advance,
            "Should not advance on first update even when near end of step"
        );

        // Get the next iteration with updated internal state
        let next_condition = result1.next_iteration;

        // Second update: User has moved far enough from the route (> 20 meters)
        // ~55 meters north of the route (0.0005 degrees latitude)
        let user_location_far = make_user_location(coord!(x: 0.001, y: 0.0005), 5.0);

        let trip_state2 = get_navigating_trip_state(
            user_location_far,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // Now should advance because the entry/exit condition has maintained its state
        // through the OR composite condition
        let result2 = next_condition.should_advance_step(trip_state2);

        assert!(
            result2.should_advance,
            "Should advance when stateful condition completes within OR composite"
        );
    }

    #[test]
    fn test_entry_and_exit_condition_resets_in_and_composite_when_advancing() {
        // Create a condition that requires proximity to end followed by distance from step
        let entry_exit_condition = DistanceEntryAndExitCondition {
            distance_to_end_of_step: 10,
            distance_after_end_of_step: 5,
            minimum_horizontal_accuracy: 5,
            has_reached_end_of_current_step: false,
        };

        // Create a condition that's true for both near and far locations
        let distance_condition = DistanceToEndOfStepCondition {
            minimum_horizontal_accuracy: 10,
            distance: 100, // True for both test locations
        };

        // Create an AND condition combining both
        let and_condition = AndAdvanceConditions {
            conditions: vec![Arc::new(entry_exit_condition), Arc::new(distance_condition)],
        };

        let trip_state = get_navigating_trip_state(
            *LOCATION_NEAR_END_OF_STEP,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // First update: User is close to the end of the step
        // Should not advance yet, but should update internal state of the entry/exit condition
        let result1 = and_condition.should_advance_step(trip_state);

        assert!(
            !result1.should_advance,
            "Should not advance on first update even when near end of step"
        );

        // Get the next iteration with updated internal state
        let next_condition = result1.next_iteration;

        // Second update: User has moved far enough from the route (> 5 meters)
        // ~55 meters north of the route (0.0005 degrees latitude)
        let user_location_far = make_user_location(coord!(x: 0.001, y: 0.0005), 5.0);

        let trip_state2 = get_navigating_trip_state(
            user_location_far,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // Now should advance because the entry/exit condition has maintained its state
        // through the AND composite condition
        let result2 = next_condition.should_advance_step(trip_state2);

        assert!(
            result2.should_advance,
            "Should advance when stateful condition completes within AND composite"
        );

        // The key test: verify that the next iteration after advancing has reset conditions
        let reset_condition = result2.next_iteration;

        let trip_state3 = get_navigating_trip_state(
            *LOCATION_NEAR_END_OF_STEP,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // Third update: User is near the end again, but the entry/exit condition should be reset
        // Since the entry/exit condition is reset, it should start over even though user is at end
        let result3 = reset_condition.should_advance_step(trip_state3);

        assert!(
            !result3.should_advance,
            "Should not advance immediately after reset - entry/exit condition should restart its two-phase process"
        );
    }

    #[test]
    fn test_route_snapped_entry_and_exit_condition_advance() {
        // Create a straight route with two steps
        let step1 = gen_route_step_with_coords(vec![
            coord!(x: 0.0, y: 0.0),   // Start
            coord!(x: 0.001, y: 0.0), // 111m east (end of step 1)
        ]);

        let step2 = gen_route_step_with_coords(vec![
            coord!(x: 0.001, y: 0.0),   // Start of step 2 (same as end of step 1)
            coord!(x: 0.001, y: 0.001), // 111m north
        ]);

        let condition = DistanceEntryAndSnappedExitCondition {
            distance_to_end_of_step: 10,
            distance_after_end_of_step: 5,
            minimum_horizontal_accuracy: 10,
            has_reached_end_of_current_step: false,
        };

        // User near end of step 1
        let location_near_end = make_user_location(coord!(x: 0.00099, y: 0.0), 5.0);
        let trip_state = get_navigating_trip_state(
            location_near_end,
            vec![step1],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // First update: Should enter the zone but not advance
        let result1 = condition.should_advance_step(trip_state);

        assert!(
            !result1.should_advance,
            "Should not advance on first update when entering end zone"
        );

        // Second update: User has turned onto step 2 (10m north of the corner)
        let location_on_step2 = make_user_location(coord!(x: 0.001, y: 0.0001), 5.0);
        let next_condition = result1.next_iteration;
        let trip_state2 = get_navigating_trip_state(
            location_on_step2,
            vec![step2],
            vec![],
            RouteDeviation::NoDeviation,
        );

        let result2 = next_condition.should_advance_step(trip_state2);

        assert!(
            result2.should_advance,
            "Should advance when route-snapped position has moved onto next step"
        );
    }

    #[test]
    fn test_route_snapped_entry_and_exit_with_short_next_step() {
        // Create a route where step 1 is normal length, but step 2 and 3 are short
        let step1 = gen_route_step_with_coords(vec![
            coord!(x: 0.0, y: 0.0),   // Start
            coord!(x: 0.001, y: 0.0), // 111m east (end of step 1)
        ]);

        // Step 2 is short - ~3 meters long
        let step2 = gen_route_step_with_coords(vec![
            coord!(x: 0.001, y: 0.0),      // Start of step 2
            coord!(x: 0.001, y: 0.000027), // ~3m north
        ]);

        // Step 3 is also short - ~3 meters long
        // Total accumulated distance: 3 + 3 = 6m, less than configured 10m
        let step3 = gen_route_step_with_coords(vec![
            coord!(x: 0.001, y: 0.000027), // Start of step 3
            coord!(x: 0.001, y: 0.000054), // ~3m north
        ]);

        // Configure with 10m exit distance, but step 2 + step 3 = only 6m total
        // The algorithm should cap the effective exit distance to min(10, 6) = 6m
        let condition = DistanceEntryAndSnappedExitCondition {
            distance_to_end_of_step: 10,
            distance_after_end_of_step: 10, // Larger than accumulated distance!
            minimum_horizontal_accuracy: 10,
            has_reached_end_of_current_step: false,
        };

        // User near end of step 1
        let location_near_end = make_user_location(coord!(x: 0.00099, y: 0.0), 5.0);
        let trip_state = get_navigating_trip_state(
            location_near_end,
            vec![step1, step2.clone(), step3.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // First update: Enter the end zone
        let result1 = condition.should_advance_step(trip_state);

        assert!(
            !result1.should_advance,
            "Should not advance on first update when entering end zone"
        );

        // Second update: User has moved 8m north from the turn (well past the short steps)
        // With correct code using min(10, 6), effective_exit_distance is 6m
        // The perpendicular deviation from step1 should exceed 6m, so should advance
        let location_on_step2 = make_user_location(coord!(x: 0.001, y: 0.000072), 5.0);
        let next_condition = result1.next_iteration;
        let trip_state2 = get_navigating_trip_state(
            location_on_step2,
            vec![step2, step3],
            vec![],
            RouteDeviation::NoDeviation,
        );

        let result2 = next_condition.should_advance_step(trip_state2);

        assert!(
            result2.should_advance,
            "Should advance with short next steps using min(configured, accumulated) distance"
        );
    }

    #[test]
    fn test_route_snapped_entry_and_exit_with_zero_length_via_waypoint() {
        // Create a route with a normal step, a 0-length via waypoint step, and another normal step
        let step1 = gen_route_step_with_coords(vec![
            coord!(x: 0.0, y: 0.0),   // Start
            coord!(x: 0.001, y: 0.0), // 111m east (end of step 1)
        ]);

        // Step 2 is a via waypoint with 0 distance (same start and end point)
        let mut step2 = gen_route_step_with_coords(vec![
            coord!(x: 0.001, y: 0.0), // Via waypoint location (duplicated)
            coord!(x: 0.001, y: 0.0), // Same point
        ]);
        step2.distance = 0.0; // Explicitly set to 0 distance

        // Step 3 is a normal step continuing from the via waypoint
        let step3 = gen_route_step_with_coords(vec![
            coord!(x: 0.001, y: 0.0),   // Start (via waypoint)
            coord!(x: 0.001, y: 0.001), // 111m north
        ]);

        let condition = DistanceEntryAndSnappedExitCondition {
            distance_to_end_of_step: 10,
            distance_after_end_of_step: 5,
            minimum_horizontal_accuracy: 10,
            has_reached_end_of_current_step: false,
        };

        // User near end of step 1
        let location_near_end = make_user_location(coord!(x: 0.00099, y: 0.0), 5.0);
        let trip_state = get_navigating_trip_state(
            location_near_end,
            vec![step1, step2.clone(), step3.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // First update: Should enter the zone but not advance
        let result1 = condition.should_advance_step(trip_state);

        assert!(
            !result1.should_advance,
            "Should not advance on first update when entering end zone"
        );

        // Second update: User has moved onto step 3 (past the 0-length via waypoint)
        // The algorithm should accumulate geometry from step2 (0m) + step3 (111m) to have sufficient distance
        let location_on_step3 = make_user_location(coord!(x: 0.001, y: 0.0001), 5.0);
        let next_condition = result1.next_iteration;
        let trip_state2 = get_navigating_trip_state(
            location_on_step3,
            vec![step2, step3],
            vec![],
            RouteDeviation::NoDeviation,
        );

        let result2 = next_condition.should_advance_step(trip_state2);

        assert!(
            result2.should_advance,
            "Should advance when route-snapped position has moved onto step after 0-length via waypoint"
        );
    }

    #[test]
    fn test_entry_and_exit_condition_resets_in_or_composite_when_advancing() {
        // Create a condition that requires proximity to end followed by distance from step
        let entry_exit_condition = DistanceEntryAndExitCondition {
            distance_to_end_of_step: 10,
            distance_after_end_of_step: 5,
            minimum_horizontal_accuracy: 5,
            has_reached_end_of_current_step: false,
        };

        // Create a condition that will never be true (manual)
        let manual_condition = ManualStepCondition;

        // Create an OR condition combining both
        let or_condition = OrAdvanceConditions {
            conditions: vec![Arc::new(entry_exit_condition), Arc::new(manual_condition)],
        };

        let trip_state = get_navigating_trip_state(
            *LOCATION_NEAR_END_OF_STEP,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // First update: User is close to the end of the step
        // Should not advance yet, but should update internal state of the entry/exit condition
        let result1 = or_condition.should_advance_step(trip_state);

        assert!(
            !result1.should_advance,
            "Should not advance on first update even when near end of step"
        );

        // Get the next iteration with updated internal state
        let next_condition = result1.next_iteration;

        // Second update: User has moved far enough from the route (> 5 meters)
        // ~55 meters north of the route (0.0005 degrees latitude)
        let user_location_far = make_user_location(coord!(x: 0.001, y: 0.0005), 5.0);

        let trip_state2 = get_navigating_trip_state(
            user_location_far,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // Now should advance because the entry/exit condition has maintained its state
        let result2 = next_condition.should_advance_step(trip_state2);

        assert!(
            result2.should_advance,
            "Should advance when stateful condition completes within OR composite"
        );

        // The key test: verify that the next iteration after advancing has reset conditions
        let reset_condition = result2.next_iteration;

        let trip_state3 = get_navigating_trip_state(
            *LOCATION_NEAR_END_OF_STEP,
            vec![STRAIGHT_LINE_SHORT_ROUTE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // Third update: User is near the end again, but the entry/exit condition should be reset
        // Since the entry/exit condition is reset, it should start over even though user is at end
        let result3 = reset_condition.should_advance_step(trip_state3);

        assert!(
            !result3.should_advance,
            "Should not advance immediately after reset - entry/exit condition should restart its two-phase process"
        );
    }
}

#[cfg(test)]
proptest! {
    #[test]
    fn manual_step_never_advances(
        c1 in arb_coord(),
        c2 in arb_coord(),
        accuracy: f64
    ) {
        // Create a straight line random route step
        let route_step =
            crate::navigation_controller::test_helpers::gen_route_step_with_coords(vec![c1, c2]);

        // User location exactly at the end of the step
        let user_location = make_user_location(c2, accuracy);

        let condition = ManualStepCondition;

        let trip_state = get_navigating_trip_state(
            user_location,
            vec![route_step],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // Test the condition - we should NOT advance since we're far from the end
        let result = condition.should_advance_step(trip_state);

        // We should never advance to the next step in manual mode,
        // so the list should always be empty.
        prop_assert!(
            !result.should_advance,
            "Should not advance with the manual condition"
        );
    }

    #[test]
    fn entry_and_exit_never_advances_on_zero_movement(
        c1 in arb_coord(),
        c2 in arb_coord(),
    ) {
        // Create a straight line random route step
        let route_step =
            crate::navigation_controller::test_helpers::gen_route_step_with_coords(vec![c1, c2]);

        // User location exactly at the end of the step
        let user_location = make_user_location(c2, 5.0);

        // Create a condition that requires proximity to end followed by distance from step
        let condition = DistanceEntryAndExitCondition {
            distance_to_end_of_step: 10,
            distance_after_end_of_step: 20,
            minimum_horizontal_accuracy: 5,
            has_reached_end_of_current_step: false,
        };

        let trip_state = get_navigating_trip_state(
            user_location,
            vec![route_step.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // First update: User is close to the end of the step...
        // Should not advance yet, but should update internal state
        let result1 = condition.should_advance_step(trip_state);

        prop_assert!(
            !result1.should_advance,
            "Should not advance on first update even when at the end of the step"
        );

        // Second update: User has not moved

        // Get the next iteration from the first result
        let next_condition = result1.next_iteration;

        let trip_state2 = get_navigating_trip_state(
            user_location,
            vec![route_step],
            vec![],
            RouteDeviation::NoDeviation,
        );

        // Should still not advance because we haven't moved far enough away
        let result2 = next_condition.should_advance_step(trip_state2);

        prop_assert!(
            !result2.should_advance,
            "Should not advance when user hasn't moved far enough from the route"
        );
    }

    // TODO: handling of accuracy parameter for "always" advance

    // TODO: "or" advance with one condition that's always trivially true and another which is always false

    // TODO: enter+exit with two updates: one exact, and another that exceeds the distance threshold (could generate such a coordinate with polar formulas; probably a crate for that if our existing ones can't do it)

    // TODO: Similar to the above, but with, say, 5 random updates where the user is *always* within the distance threshold, so they never advance to the next step
}

#[cfg(test)]
mod off_step_tests {
    use super::*;
    use crate::models::UserLocation;
    use crate::navigation_controller::test_helpers::get_navigating_trip_state;
    use crate::test_utils::make_user_location;
    use geo::coord;
    use std::sync::LazyLock;

    use crate::models::RouteStep;
    use crate::navigation_controller::test_helpers::gen_route_step_with_coords;

    static STRAIGHT_LINE_STEP: LazyLock<RouteStep> = LazyLock::new(|| {
        gen_route_step_with_coords(vec![
            coord!(x: 0.0, y: 0.0),
            coord!(x: 0.001, y: 0.0), // 111 meters east
        ])
    });

    static LOCATION_FAR_FROM_STEP: LazyLock<UserLocation> =
        LazyLock::new(|| make_user_location(coord!(x: 0.005, y: 0.0005), 5.0));

    #[test]
    fn test_always_policy_advances_when_off_step_on_route() {
        let condition = DistanceFromStepCondition {
            minimum_horizontal_accuracy: 10,
            distance: 100,
            calculation_policy: DeviationCalculationPolicy::Always,
        };

        let trip_state = get_navigating_trip_state(
            *LOCATION_FAR_FROM_STEP,
            vec![STRAIGHT_LINE_STEP.clone()],
            vec![],
            RouteDeviation::Deviation {
                kind: DeviationKind::OffStepOnRoute {
                    deviation_from_step_line: 50.0,
                },
            },
        );

        let result = condition.should_advance_step(trip_state);
        assert!(
            result.should_advance,
            "Always should advance regardless of deviation status"
        );
    }

    #[test]
    fn test_while_on_current_step_policy_blocks_advance_when_off_step_on_route() {
        let condition = DistanceFromStepCondition {
            minimum_horizontal_accuracy: 10,
            distance: 100,
            calculation_policy: DeviationCalculationPolicy::WhileOnCurrentStep,
        };

        let trip_state = get_navigating_trip_state(
            *LOCATION_FAR_FROM_STEP,
            vec![STRAIGHT_LINE_STEP.clone()],
            vec![],
            RouteDeviation::Deviation {
                kind: DeviationKind::OffStepOnRoute {
                    deviation_from_step_line: 50.0,
                },
            },
        );

        let result = condition.should_advance_step(trip_state);
        assert!(
            !result.should_advance,
            "WhileOnCurrentStep should block advance once the user is off the current step"
        );
    }

    #[test]
    fn test_while_on_route_policy_advances_when_off_step_on_route() {
        // WhileOnRoute should permit advance when the user is off the current step
        // but still on a future step on the route polyline.
        let condition = DistanceFromStepCondition {
            minimum_horizontal_accuracy: 10,
            distance: 100,
            calculation_policy: DeviationCalculationPolicy::WhileOnRoute,
        };

        let trip_state = get_navigating_trip_state(
            *LOCATION_FAR_FROM_STEP,
            vec![STRAIGHT_LINE_STEP.clone()],
            vec![],
            RouteDeviation::Deviation {
                kind: DeviationKind::OffStepOnRoute {
                    deviation_from_step_line: 50.0,
                },
            },
        );

        let result = condition.should_advance_step(trip_state);
        assert!(
            result.should_advance,
            "WhileOnRoute should not block advancement when only off the current step"
        );
    }

    #[test]
    fn test_while_on_current_step_policy_blocks_advance_when_completely_off_route() {
        let condition = DistanceFromStepCondition {
            minimum_horizontal_accuracy: 10,
            distance: 100,
            // `WhileOnCurrentStep` blocks advancement on *any*
            // deviation, including `CompletelyOffRoute`.
            // Being completely off the route is itself a (stronger) form of being off the current step.
            calculation_policy: DeviationCalculationPolicy::WhileOnCurrentStep,
        };

        let trip_state = get_navigating_trip_state(
            *LOCATION_FAR_FROM_STEP,
            vec![STRAIGHT_LINE_STEP.clone()],
            vec![],
            RouteDeviation::Deviation {
                kind: DeviationKind::CompletelyOffRoute {
                    deviation_from_route_line: 200.0,
                },
            },
        );

        let result = condition.should_advance_step(trip_state);
        assert!(
            !result.should_advance,
            "WhileOnCurrentStep must block advancement even when CompletelyOffRoute, \
             since being off the route is itself being off the current step"
        );
    }

    #[test]
    fn test_while_on_route_policy_blocks_advance_when_completely_off_route() {
        let condition = DistanceFromStepCondition {
            minimum_horizontal_accuracy: 10,
            distance: 100,
            calculation_policy: DeviationCalculationPolicy::WhileOnRoute,
        };

        let trip_state = get_navigating_trip_state(
            *LOCATION_FAR_FROM_STEP,
            vec![STRAIGHT_LINE_STEP.clone()],
            vec![],
            RouteDeviation::Deviation {
                kind: DeviationKind::CompletelyOffRoute {
                    deviation_from_route_line: 200.0,
                },
            },
        );

        let result = condition.should_advance_step(trip_state);
        assert!(
            !result.should_advance,
            "WhileOnRoute should block advancement when the user is completely off the route"
        );
    }

    #[test]
    fn test_while_on_current_step_policy_handles_all_deviation_states() {
        let condition = DistanceFromStepCondition {
            minimum_horizontal_accuracy: 10,
            distance: 100,
            calculation_policy: DeviationCalculationPolicy::WhileOnCurrentStep,
        };

        // OffStepOnRoute: blocked
        let trip_state_off_step = get_navigating_trip_state(
            *LOCATION_FAR_FROM_STEP,
            vec![STRAIGHT_LINE_STEP.clone()],
            vec![],
            RouteDeviation::Deviation {
                kind: DeviationKind::OffStepOnRoute {
                    deviation_from_step_line: 50.0,
                },
            },
        );
        let result = condition.should_advance_step(trip_state_off_step);
        assert!(
            !result.should_advance,
            "WhileOnCurrentStep should block on OffStepOnRoute"
        );

        // CompletelyOffRoute: blocked
        let trip_state_off_route = get_navigating_trip_state(
            *LOCATION_FAR_FROM_STEP,
            vec![STRAIGHT_LINE_STEP.clone()],
            vec![],
            RouteDeviation::Deviation {
                kind: DeviationKind::CompletelyOffRoute {
                    deviation_from_route_line: 200.0,
                },
            },
        );
        let result = condition.should_advance_step(trip_state_off_route);
        assert!(
            !result.should_advance,
            "WhileOnCurrentStep should block on CompletelyOffRoute"
        );

        // NoDeviation: allowed
        let trip_state_on_route = get_navigating_trip_state(
            *LOCATION_FAR_FROM_STEP,
            vec![STRAIGHT_LINE_STEP.clone()],
            vec![],
            RouteDeviation::NoDeviation,
        );
        let result = condition.should_advance_step(trip_state_on_route);
        assert!(
            result.should_advance,
            "WhileOnCurrentStep should still allow advance when NoDeviation"
        );
    }
}