//! Geolocation manager — cross-platform state for the GPS/location surface

//! (`SUPER_PLAN_2` §1.5 + research/04 §3 + research/08 §6).

//!

//! Three callers drive it:

//!

//! - The **layout pass** scans the styled DOM for `GeolocationProbe`

//!   `NodeTypes`. When the first probe appears the framework fires

//!   `PermissionDiffEvent::Subscribe(Capability::Geolocation)` and the

//!   platform backend starts a native `CLLocationManager` /

//!   `LocationManager` / `geoclue` subscription. The reverse on the

//!   last probe leaving.

//!

//! - The **platform backend** (`dll/src/desktop/extra/geolocation/<plat>.rs`)

//!   calls `set_latest_fix(...)` whenever the native subscription

//!   delivers an update. The manager debounces and records the most

//!   recent value; callbacks read it via `CallbackInfo::get_geolocation_fix`.

//!

//! - **Callbacks** read `latest_fix()` synchronously to render the map

//!   centre, decide whether to show "acquiring signal…", etc.

//!

//! No platform deps; `no_std`-friendly via `alloc::collections::BTreeMap`.

use alloc::collections::btree_map::BTreeMap;

use alloc::vec::Vec;

use azul_core::dom::DomNodeId;

use azul_core::events::{

    EventData, EventProvider, EventSource as CoreEventSource, EventType, SyntheticEvent,

};

use azul_core::task::Instant;

// `LocationFix` + `GeolocationProbeConfig` live in `azul-core` so

// `NodeType::GeolocationProbe(GeolocationProbeConfig)` can reference

// the config struct without a cyclic dep on `azul-layout`. We re-export

// them here for the existing `azul_layout::managers::geolocation::*`

// import paths.

pub use azul_core::geolocation::{GeolocationProbeConfig, LocationFix};

/// Diff event the layout pass emits when a probe appears or disappears.

/// Symmetric to `PermissionDiffEvent` — drives the platform backend's

/// native subscribe / release calls.

#[derive(Debug, Clone, Copy, PartialEq, Eq)]

#[repr(C, u8)]

pub enum GeolocationDiffEvent {

    /// First probe of this config landed in the layout — start a

    /// native subscription with these options.

    Subscribe { config: GeolocationProbeConfig },

    /// Last probe left — stop the native subscription.

    Release,

    /// Probe config changed without subscriber churn — reconfigure

    /// the running subscription in place (e.g. `high_accuracy` false →

    /// true).

    Reconfigure { config: GeolocationProbeConfig },

}

/// Cross-platform geolocation state. One per `App` (the OS gives us

/// a single per-process subscription, not per-window).

#[derive(Debug, Clone, PartialEq, Default)]

pub struct GeolocationManager {

    /// Most recent fix from the platform backend, or `None` until the

    /// first native sample arrives (or `None` again after a Release).

    pub latest_fix: Option<LocationFix>,

    /// Active probe config — set on each Subscribe / Reconfigure,

    /// cleared on Release.

    pub active_config: Option<GeolocationProbeConfig>,

    /// Diff queue drained once per frame by the platform backend.

    pending_events: Vec<GeolocationDiffEvent>,

    /// Refcount of `GeolocationProbe` nodes currently in the layout.

    refcount: u32,

    /// `true` when a fix advanced since the last event-pass drain. Set by

    /// [`set_latest_fix`](Self::set_latest_fix), read by the `EventProvider`

    /// impl (yields `EventType::GeolocationFix`), cleared by

    /// [`clear_pending_event`](Self::clear_pending_event) after dispatch

    /// (MWA-A1 — this manager previously computed fixes nobody dispatched).

    pending_event: bool,

    /// Most recent backend error (subscription failed / timed out /

    /// revoked), or `None`. Cleared on the next successful fix (MWA-A1b).

    pub last_error: Option<LocationError>,

    /// `true` when an error arrived since the last event-pass drain — the

    /// `EventProvider` impl yields `EventType::GeolocationError` for it.

    pending_error_event: bool,

}

/// Error from the native geolocation backend (MWA-A1b).

///

/// Layout-internal

/// (not FFI-exposed) until the `CallbackInfo` getter lands with the Phase C

/// geolocation item — the `GeolocationError` EVENT carries no payload, so

/// callbacks poll this via the manager.

#[derive(Debug, Clone, PartialEq, Eq, Default)]

pub struct LocationError {

    /// Platform-specific error code (`CLError` code / `GError` code / HRESULT).

    pub code: u32,

    /// Human-readable message from the backend.

    pub message: String,

}

impl GeolocationManager {

    /// Platform backend writes the freshly-received fix. Returns true

    /// if the fix actually advanced (different from the previous one)

    /// so the caller can mark the window dirty for relayout.

    ///

    /// Compared via bit-pattern equality so missing fields (encoded as

    /// `f32::NAN`) compare equal — `PartialEq` returns `false` on

    /// NaN-vs-NaN, which would make every fix look "changed" even

    /// when nothing actually moved.

    /// Platform backend reports a subscription error (MWA-A1b). Always

    /// raises the error-event flag — repeated errors each answer a live

    /// subscription and callbacks should hear every one.

    /// Clear the pending-event flags (fix + error). The dll calls this

    /// after the event pass has collected the geolocation events.

    /// `true` while at least one `GeolocationProbe` is mounted — the

    /// capability pump keeps its drain timer armed while this holds, so

    /// fixes parked by the native backend reach callbacks without waiting

    /// for unrelated input (MWA-A1 arming signal).

    /// Drain queued diff events. Platform backend calls this once per

    /// frame.

    /// Diff entry point. The layout pass walks the styled DOM for

    /// `GeolocationProbe` nodes and feeds each `(config, node_id)`

    /// pair to the closure. The manager bumps the refcount, watches

    /// for config drift, and enqueues the right Subscribe / Release /

    /// Reconfigure event.

    {

            // First probe's config wins. Subsequent probes that

            // disagree are accepted silently — a real app shouldn't

            // mount two `GeolocationProbe`s with different configs

            // but the framework can't assert that here.

                // Both frames have probes. Emit Reconfigure if the

                // config actually drifted.

            }

        }

}

impl EventProvider for GeolocationManager {

    /// Yield a window-level `GeolocationFix` event when a fix advanced since

    /// the last drain (target = root; read the value via

    /// `CallbackInfo::get_geolocation_fix` inside the callback). Mirrors the

    /// sensor / gamepad providers; before MWA-A1 nothing ever produced

    /// `EventType::GeolocationFix`, so fix callbacks could never fire.

}

// ────────── Async fix channel (platform backend → manager) ────────────

//

// A native location callback (Android `FusedLocationProvider`

// `onLocationResult`, iOS `CLLocationManagerDelegate`) fires on an

// arbitrary thread with no handle to the live `GeolocationManager` (it

// lives inside the window's `LayoutWindow`). The backend parks each fix

// here; the layout pass drains it once per frame via

// [`drain_location_fixes`] and applies the latest through

// [`GeolocationManager::set_latest_fix`]. Pure Rust — no platform

// dependency (SUPER_PLAN_2 §0.5). Mirrors the permission manager's

// async-result channel.

static PENDING_FIXES: std::sync::Mutex<Vec<LocationFix>> =

    std::sync::Mutex::new(Vec::new());

/// Park a location fix delivered by a platform backend (in the dll).

/// Thread-safe; recovers from a poisoned lock so one panicking applier

/// can't wedge delivery forever.

/// Drain every fix parked by [`push_location_fix`], in arrival order.

/// Called once per layout pass; the caller applies them through

/// [`GeolocationManager::set_latest_fix`] (the last one wins).

// Error channel (MWA-A1b) — same shape as the fix channel: the native

// backend's error callback fires on an OS thread and parks here; the

// capability pump drains into `set_last_error`.

static PENDING_ERRORS: std::sync::Mutex<Vec<LocationError>> =

    std::sync::Mutex::new(Vec::new());

/// Park a geolocation error delivered by a platform backend (in the dll).

/// Thread-safe; poison-recovering.

/// Drain every error parked by [`push_location_error`], in arrival order.

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    #[test]

    #[test]

            }

        }

    #[test]

        // Same config across frames — no events.

    #[test]

    #[test]

    #[test]

        use azul_core::task::{Instant, SystemTick};

        // An identical fix is not a change — no re-fire.

    #[test]

        use azul_core::task::{Instant, SystemTick};

            EventType::GeolocationError

        );

        // a successful (changed) fix supersedes the stored error

    #[test]

    #[test]

    #[allow(clippy::float_cmp)] // test asserts exact float equality on deterministic values

        // The channel is process-global; clear any residue first.

        // Applying them reflects in latest_fix() — what the layout pass does.

        // A second drain is empty — the queue was taken, not copied.

}

#[cfg(test)]

#[allow(clippy::float_cmp, clippy::eq_op, clippy::redundant_clone)]

mod autotest_generated {

    use azul_core::task::{Instant, SystemTick};

    use super::*;

    // ─────────────────────────── helpers ────────────────────────────

    /// A fix where every optional field is *present* — knocking out a single

    /// field then flips exactly one comparison.

    const fn full_fix() -> LocationFix {

        LocationFix {

            latitude_deg: 48.208_8,

            longitude_deg: 16.372_1,

            accuracy_m: 5.0,

            altitude_m: 171.0,

            altitude_accuracy_m: 3.0,

            heading_deg: 90.0,

            speed_mps: 1.5,

            timestamp_ms: 1_234,

        }

    }

    /// "Platform reported nothing but lat/lon" — the NaN-heavy shape

    /// `set_latest_fix` documents as the reason it compares bit patterns.

    const fn nan_fix() -> LocationFix {

        LocationFix {

            latitude_deg: 37.0,

            longitude_deg: -122.0,

            accuracy_m: 10.0,

            altitude_m: f32::NAN,

            altitude_accuracy_m: f32::NAN,

            heading_deg: f32::NAN,

            speed_mps: f32::NAN,

            timestamp_ms: 0,

        }

    }

    const fn probe_cfg(high_accuracy: bool, max_accuracy_m: f32) -> GeolocationProbeConfig {

        GeolocationProbeConfig {

            high_accuracy,

            background: false,

            max_accuracy_m,

            min_interval_ms: 0,

        }

    }

    fn tick() -> Instant {

        Instant::Tick(SystemTick::new(0))

    }

    /// The 8 single-field mutations of [`full_fix`], one per field the

    /// bit-pattern comparison has to look at.

    fn single_field_mutations() -> Vec<(&'static str, LocationFix)> {

        let base = full_fix();

        let mut out = Vec::new();

        let mut f = base;

        f.latitude_deg = -48.208_8;

        out.push(("latitude_deg", f));

        let mut f = base;

        f.longitude_deg = 16.372_2;

        out.push(("longitude_deg", f));

        let mut f = base;

        f.accuracy_m = 5.000_001;

        out.push(("accuracy_m", f));

        let mut f = base;

        f.altitude_m = f32::NAN;

        out.push(("altitude_m", f));

        let mut f = base;

        f.altitude_accuracy_m = f32::NAN;

        out.push(("altitude_accuracy_m", f));

        let mut f = base;

        f.heading_deg = 270.0;

        out.push(("heading_deg", f));

        let mut f = base;

        f.speed_mps = -1.5;

        out.push(("speed_mps", f));

        let mut f = base;

        f.timestamp_ms = u64::MAX;

        out.push(("timestamp_ms", f));

        out

    }

    // ───────────────────── constructor / getters ────────────────────

    #[test]

    fn new_equals_default_and_holds_construction_invariants() {

        let mgr = GeolocationManager::new();

        assert_eq!(mgr, GeolocationManager::default());

        assert_eq!(mgr, GeolocationManager::new(), "construction is deterministic");

        assert_eq!(mgr.latest_fix(), None);

        assert_eq!(mgr.refcount(), 0);

        assert_eq!(mgr.active_config, None);

        assert_eq!(mgr.last_error, None);

        assert!(!mgr.has_active_subscription());

        assert!(mgr.get_pending_events(tick()).is_empty());

    }

    #[test]

    fn getters_on_a_fresh_manager_do_not_panic() {

        let mut mgr = GeolocationManager::new();

        // Repeated reads of an empty manager stay None / 0 and never panic.

        for _ in 0..3 {

            assert_eq!(mgr.latest_fix(), None);

            assert_eq!(mgr.refcount(), 0);

            assert!(!mgr.has_active_subscription());

            assert!(mgr.take_pending_events().is_empty());

            mgr.clear_pending_event();

        }

    }

    #[test]

    fn latest_fix_round_trips_extreme_bit_patterns() {

        let extreme = LocationFix {

            latitude_deg: f64::INFINITY,

            longitude_deg: f64::NEG_INFINITY,

            accuracy_m: f32::MAX,

            altitude_m: f32::MIN_POSITIVE,

            altitude_accuracy_m: f32::from_bits(1), // subnormal

            heading_deg: -0.0,

            speed_mps: f32::NEG_INFINITY,

            timestamp_ms: u64::MAX,

        };

        let mut mgr = GeolocationManager::new();

        assert!(mgr.set_latest_fix(extreme), "first fix is always a change");

        let got = mgr.latest_fix().expect("a fix was stored");

        // encode == decode, bit for bit (not float-eq: -0.0 and subnormals).

        assert_eq!(got.latitude_deg.to_bits(), extreme.latitude_deg.to_bits());

        assert_eq!(got.longitude_deg.to_bits(), extreme.longitude_deg.to_bits());

        assert_eq!(got.accuracy_m.to_bits(), extreme.accuracy_m.to_bits());

        assert_eq!(got.altitude_m.to_bits(), extreme.altitude_m.to_bits());

        assert_eq!(

            got.altitude_accuracy_m.to_bits(),

            extreme.altitude_accuracy_m.to_bits()

        );

        assert_eq!(got.heading_deg.to_bits(), extreme.heading_deg.to_bits());

        assert_eq!(got.speed_mps.to_bits(), extreme.speed_mps.to_bits());

        assert_eq!(got.timestamp_ms, u64::MAX);

        // Infinities are *not* NaN, so the getters report them as present.

        assert_eq!(got.speed(), Some(f32::NEG_INFINITY));

        assert!(mgr.latest_fix().is_some());

        // Re-applying the identical extreme fix is not a change.

        assert!(!mgr.set_latest_fix(extreme));

    }

    #[test]

    fn nan_fix_round_trips_and_getters_still_report_missing() {

        let mut mgr = GeolocationManager::new();

        assert!(mgr.set_latest_fix(nan_fix()));

        let got = mgr.latest_fix().expect("a fix was stored");

        assert_eq!(got.altitude(), None);

        assert_eq!(got.altitude_accuracy(), None);

        assert_eq!(got.heading(), None);

        assert_eq!(got.speed(), None);

        assert_eq!(got.latitude_deg.to_bits(), 37.0_f64.to_bits());

    }

    // ───────────────── location_fix_bitwise_eq (private) ─────────────

    #[test]

    fn bitwise_eq_is_reflexive_on_nan_unlike_partial_eq() {

        let f = nan_fix();

        // Derived PartialEq is *not* reflexive here — that is the whole

        // reason `set_latest_fix` compares bit patterns instead.

        assert!(f != f, "PartialEq on a NaN-carrying fix is not reflexive");

        assert!(GeolocationManager::location_fix_bitwise_eq(&f, &f));

        assert!(GeolocationManager::location_fix_bitwise_eq(&nan_fix(), &nan_fix()));

    }

    #[test]

    fn bitwise_eq_is_reflexive_and_symmetric_over_extremes() {

        let extremes = [

            full_fix(),

            nan_fix(),

            LocationFix {

                latitude_deg: f64::INFINITY,

                longitude_deg: f64::NEG_INFINITY,

                accuracy_m: f32::INFINITY,

                altitude_m: f32::MAX,

                altitude_accuracy_m: f32::MIN,

                heading_deg: f32::from_bits(1),

                speed_mps: -0.0,

                timestamp_ms: u64::MAX,

            },

            LocationFix {

                latitude_deg: 0.0,

                longitude_deg: 0.0,

                accuracy_m: 0.0,

                altitude_m: 0.0,

                altitude_accuracy_m: 0.0,

                heading_deg: 0.0,

                speed_mps: 0.0,

                timestamp_ms: 0,

            },

        ];

        for (i, a) in extremes.iter().enumerate() {

            assert!(

                GeolocationManager::location_fix_bitwise_eq(a, a),

                "not reflexive for extreme #{i}"

            );

            for (j, b) in extremes.iter().enumerate() {

                assert_eq!(

                    GeolocationManager::location_fix_bitwise_eq(a, b),

                    GeolocationManager::location_fix_bitwise_eq(b, a),

                    "not symmetric for ({i}, {j})"

                );

                if i != j {

                    assert!(

                        !GeolocationManager::location_fix_bitwise_eq(a, b),

                        "distinct extremes #{i}/#{j} compared equal"

                    );

                }

            }

        }

    }

    #[test]

    fn bitwise_eq_looks_at_every_field() {

        let base = full_fix();

        for (field, mutated) in single_field_mutations() {

            assert!(

                !GeolocationManager::location_fix_bitwise_eq(&base, &mutated),

                "`{field}` is ignored by location_fix_bitwise_eq"

            );

            assert!(

                !GeolocationManager::location_fix_bitwise_eq(&mutated, &base),

                "`{field}` comparison is asymmetric"

            );

            assert!(GeolocationManager::location_fix_bitwise_eq(&mutated, &mutated));

        }

    }

    #[test]

    fn bitwise_eq_separates_positive_and_negative_zero() {

        let mut a = full_fix();

        a.heading_deg = 0.0;

        let mut b = a;

        b.heading_deg = -0.0;

        // Float equality says these are the same heading; the bit patterns

        // do not. `set_latest_fix` therefore treats +0 → -0 as a change.

        assert!(a.heading_deg == b.heading_deg);

        assert!(!GeolocationManager::location_fix_bitwise_eq(&a, &b));

    }

    // ─────────────────────── set_latest_fix ─────────────────────────

    #[test]

    fn repeated_identical_nan_fix_reports_no_change() {

        let mut mgr = GeolocationManager::new();

        assert!(mgr.set_latest_fix(nan_fix()), "first fix advances");

        for _ in 0..100 {

            assert!(

                !mgr.set_latest_fix(nan_fix()),

                "an unchanged NaN-carrying fix must not look like movement"

            );

        }

        // The one real change is still pending until the event pass drains it.

        assert_eq!(mgr.get_pending_events(tick()).len(), 1);

    }

    #[test]

    fn set_latest_fix_detects_a_change_in_every_field() {

        for (field, mutated) in single_field_mutations() {

            let mut mgr = GeolocationManager::new();

            assert!(mgr.set_latest_fix(full_fix()));

            mgr.clear_pending_event();

            assert!(

                mgr.set_latest_fix(mutated),

                "a change in `{field}` was not reported"

            );

            assert_eq!(

                mgr.get_pending_events(tick()).len(),

                1,

                "a change in `{field}` raised no GeolocationFix event"

            );

        }

    }

    #[test]

    fn set_latest_fix_survives_extreme_and_pathological_values() {

        let mut mgr = GeolocationManager::new();

        // Out-of-range coordinates: the manager stores whatever the backend

        // hands it, it is not a validator — but it must not panic.

        let pathological = [

            (f64::MAX, f64::MIN),

            (f64::INFINITY, f64::NEG_INFINITY),

            (f64::NAN, f64::NAN),

            (1e308, -1e308),

            (f64::MIN_POSITIVE, -f64::MIN_POSITIVE),

            (91.0, 181.0),    // beyond the WGS-84 range

            (-91.0, -181.0),  // …and the other way

        ];

        for (lat, lon) in pathological {

            let f = LocationFix {

                latitude_deg: lat,

                longitude_deg: lon,

                accuracy_m: f32::INFINITY,

                altitude_m: f32::NAN,

                altitude_accuracy_m: f32::NAN,

                heading_deg: f32::NAN,

                speed_mps: f32::NAN,

                timestamp_ms: u64::MAX,

            };

            mgr.set_latest_fix(f);

            let got = mgr.latest_fix().expect("stored");

            assert_eq!(got.latitude_deg.to_bits(), lat.to_bits());

            assert_eq!(got.longitude_deg.to_bits(), lon.to_bits());

            // Idempotent re-apply: even an all-NaN coordinate pair compares

            // equal to itself under bit-pattern equality.

            assert!(!mgr.set_latest_fix(f), "re-applying the same fix is not a change");

        }

    }

    #[test]

    fn timestamp_only_movement_counts_as_a_change() {

        let mut mgr = GeolocationManager::new();

        let mut f = nan_fix();

        assert!(mgr.set_latest_fix(f));

        f.timestamp_ms = u64::MAX;

        assert!(

            mgr.set_latest_fix(f),

            "a fresh sample at the same coordinates is still a new fix"

        );

        assert_eq!(mgr.latest_fix().expect("stored").timestamp_ms, u64::MAX);

    }

    #[test]

    fn a_changed_fix_supersedes_the_stored_error_but_an_unchanged_one_does_not() {

        let mut mgr = GeolocationManager::new();

        assert!(mgr.set_latest_fix(full_fix()));

        mgr.set_last_error(LocationError {

            code: 2,

            message: String::from("timed out"),

        });

        assert!(mgr.last_error.is_some());

        // Re-delivering the *same* fix is not a change, so the error survives.

        assert!(!mgr.set_latest_fix(full_fix()));

        assert!(

            mgr.last_error.is_some(),

            "an unchanged fix does not clear the error (documented `changed`-gated behaviour)"

        );

        // A fix that actually advanced clears it.

        assert!(mgr.set_latest_fix(nan_fix()));

        assert_eq!(mgr.last_error, None);

    }

    // ─────────────────────── set_last_error ─────────────────────────

    #[test]

    fn set_last_error_round_trips_extreme_payloads() {

        let huge = "x".repeat(1 << 16);

        let unicode = String::from("\u{0}dénié 🛰️\u{0301}\u{fffd}中文\u{1f680}");

        let payloads = [

            LocationError { code: 0, message: String::new() },

            LocationError { code: u32::MAX, message: huge.clone() },

            LocationError { code: 1, message: unicode.clone() },

        ];

        for err in payloads {

            let mut mgr = GeolocationManager::new();

            mgr.set_last_error(err.clone());

            let got = mgr.last_error.clone().expect("error was stored");

            assert_eq!(got, err, "error payload did not round-trip");

            assert_eq!(got.message.len(), err.message.len());

            let events = mgr.get_pending_events(tick());

            assert_eq!(events.len(), 1);

            assert_eq!(events[0].event_type, EventType::GeolocationError);

        }

        // The huge/unicode strings survived untouched.

        assert_eq!(huge.len(), 1 << 16);

        assert!(unicode.contains('\u{0}'));

    }

    #[test]

    fn every_repeated_error_raises_its_own_event() {

        let mut mgr = GeolocationManager::new();

        let err = LocationError {

            code: 7,

            message: String::from("revoked"),

        };

        for _ in 0..5 {

            mgr.set_last_error(err.clone());

            let events = mgr.get_pending_events(tick());

            assert_eq!(

                events.len(),

                1,

                "a repeated error must still answer the live subscription"

            );

            assert_eq!(events[0].event_type, EventType::GeolocationError);

            mgr.clear_pending_event();

            assert!(mgr.get_pending_events(tick()).is_empty());

        }

        assert_eq!(mgr.last_error, Some(err));

    }

    // ───────────── clear_pending_event / take_pending_events ─────────

    #[test]

    fn clear_pending_event_is_idempotent_and_spares_the_diff_queue() {

        let mut mgr = GeolocationManager::new();

        mgr.diff_layout(|emit| emit(probe_cfg(false, 0.0)));

        mgr.set_latest_fix(full_fix());

        mgr.set_last_error(LocationError {

            code: 1,

            message: String::from("e"),

        });

        for _ in 0..3 {

            mgr.clear_pending_event();

            assert!(

                mgr.get_pending_events(tick()).is_empty(),

                "clearing twice must stay cleared"

            );

        }

        // Clearing the *event* flags does not eat the queued *diff* events —

        // they are two independent queues with two independent drains.

        let diffs = mgr.take_pending_events();

        assert_eq!(diffs.len(), 1);

        assert!(matches!(diffs[0], GeolocationDiffEvent::Subscribe { .. }));

        // …nor the stored values themselves.

        assert!(mgr.latest_fix().is_some());

        assert!(mgr.last_error.is_some());

    }

    #[test]

    fn take_pending_events_drains_in_arrival_order_and_leaves_the_queue_empty() {

        let mut mgr = GeolocationManager::new();

        mgr.diff_layout(|emit| emit(probe_cfg(false, 0.0))); // Subscribe

        mgr.diff_layout(|emit| emit(probe_cfg(true, 0.0))); // Reconfigure

        mgr.diff_layout(|_emit| {}); // Release

        let events = mgr.take_pending_events();

        assert_eq!(events.len(), 3);

        assert!(matches!(events[0], GeolocationDiffEvent::Subscribe { .. }));

        assert!(matches!(events[1], GeolocationDiffEvent::Reconfigure { .. }));

        assert_eq!(events[2], GeolocationDiffEvent::Release);

        assert!(mgr.take_pending_events().is_empty(), "taken, not copied");

        assert!(mgr.take_pending_events().is_empty(), "still empty");

    }

    #[test]

    fn get_pending_events_does_not_consume_the_flags() {

        let mut mgr = GeolocationManager::new();

        mgr.set_latest_fix(full_fix());

        mgr.set_last_error(LocationError {

            code: 3,

            message: String::from("boom"),

        });

        // Both flags are up: fix first, then error.

        for _ in 0..3 {

            let events = mgr.get_pending_events(tick());

            assert_eq!(events.len(), 2, "the getter is a read, not a drain");

            assert_eq!(events[0].event_type, EventType::GeolocationFix);

            assert_eq!(events[1].event_type, EventType::GeolocationError);

            assert_eq!(events[0].target, DomNodeId::ROOT);

            assert_eq!(events[1].target, DomNodeId::ROOT);

        }

        mgr.clear_pending_event();

        assert!(mgr.get_pending_events(tick()).is_empty());

    }

    // ──────────────────────── diff_layout ───────────────────────────

    #[test]

    fn no_probes_on_a_fresh_manager_emits_nothing() {

        let mut mgr = GeolocationManager::new();

        for _ in 0..4 {

            mgr.diff_layout(|_emit| {});

            assert_eq!(mgr.refcount(), 0);

            assert!(!mgr.has_active_subscription());

            assert_eq!(mgr.active_config, None);

            assert!(

                mgr.take_pending_events().is_empty(),

                "0 → 0 must not emit a spurious Release"

            );

        }

    }

    #[test]

    fn refcount_tracks_the_probe_count_and_gates_the_subscription_flag() {

        let mut mgr = GeolocationManager::new();

        mgr.diff_layout(|emit| {

            for _ in 0..10_000 {

                emit(probe_cfg(false, 0.0));

            }

        });

        assert_eq!(mgr.refcount(), 10_000);

        assert!(mgr.has_active_subscription());

        assert_eq!(mgr.take_pending_events().len(), 1, "one Subscribe, not 10k");

        // Probe count churn with an unchanged config emits nothing at all.

        mgr.diff_layout(|emit| {

            for _ in 0..3 {

                emit(probe_cfg(false, 0.0));

            }

        });

        assert_eq!(mgr.refcount(), 3);

        assert!(mgr.has_active_subscription());

        assert!(mgr.take_pending_events().is_empty());

        // The boundary: exactly one probe still counts as subscribed.

        mgr.diff_layout(|emit| emit(probe_cfg(false, 0.0)));

        assert_eq!(mgr.refcount(), 1);

        assert!(mgr.has_active_subscription());

        mgr.diff_layout(|_emit| {});

        assert_eq!(mgr.refcount(), 0);

        assert!(!mgr.has_active_subscription(), "0 probes ⇒ no subscription");

        assert_eq!(mgr.take_pending_events(), vec![GeolocationDiffEvent::Release]);

    }

    #[test]

    fn the_first_probes_config_wins_the_subscribe() {

        let mut mgr = GeolocationManager::new();

        mgr.diff_layout(|emit| {

            emit(probe_cfg(true, 25.0));

            emit(probe_cfg(false, 999.0)); // disagreeing second probe

            emit(probe_cfg(false, 0.0));

        });

        assert_eq!(mgr.refcount(), 3);

        let events = mgr.take_pending_events();

        assert_eq!(events.len(), 1);

        match events[0] {

            GeolocationDiffEvent::Subscribe { config } => {

                assert!(config.high_accuracy);

                assert_eq!(config.max_accuracy_m, 25.0);

            }

            ref other => panic!("expected Subscribe, got {other:?}"),

        }

        assert_eq!(mgr.active_config, Some(probe_cfg(true, 25.0)));

        // A frame whose *first* probe keeps the active config emits nothing,

        // even when a later probe disagrees.

        mgr.diff_layout(|emit| {

            emit(probe_cfg(true, 25.0));

            emit(probe_cfg(false, 0.0));

        });

        assert!(mgr.take_pending_events().is_empty());

    }

    #[test]

    fn release_clears_the_fix_and_a_resubscribe_starts_from_scratch() {

        let mut mgr = GeolocationManager::new();

        mgr.diff_layout(|emit| emit(probe_cfg(false, 0.0)));

        assert!(mgr.set_latest_fix(full_fix()));

        assert!(mgr.take_pending_events().len() == 1);

        mgr.diff_layout(|_emit| {}); // Release

        assert_eq!(mgr.latest_fix(), None, "Release drops the stale fix");

        assert_eq!(mgr.active_config, None);

        assert_eq!(mgr.take_pending_events(), vec![GeolocationDiffEvent::Release]);

        // Re-mounting emits a fresh Subscribe (not a Reconfigure) and the fix

        // stays None until the backend delivers a new sample.

        mgr.diff_layout(|emit| emit(probe_cfg(true, 5.0)));

        assert_eq!(mgr.refcount(), 1);

        assert_eq!(mgr.latest_fix(), None);

        let events = mgr.take_pending_events();

        assert_eq!(events.len(), 1);

        assert_eq!(

            events[0],

            GeolocationDiffEvent::Subscribe {

                config: probe_cfg(true, 5.0)

            }

        );

    }

    #[test]

    fn release_leaves_the_fix_event_flag_raised_with_no_fix_behind_it() {

        // Characterisation of the current behaviour: `diff_layout` clears

        // `latest_fix` on Release but not `pending_event`, so the event pass

        // still dispatches a GeolocationFix whose payload is already gone.

        // Callbacks must therefore tolerate `get_geolocation_fix() == None`

        // inside a GeolocationFix handler.

        let mut mgr = GeolocationManager::new();

        mgr.diff_layout(|emit| emit(probe_cfg(false, 0.0)));

        assert!(mgr.set_latest_fix(full_fix()));

        mgr.diff_layout(|_emit| {}); // Release

        assert_eq!(mgr.latest_fix(), None);

        let events = mgr.get_pending_events(tick());

        assert_eq!(events.len(), 1);

        assert_eq!(events[0].event_type, EventType::GeolocationFix);

        mgr.clear_pending_event();

        assert!(mgr.get_pending_events(tick()).is_empty());

    }

    #[test]

    fn a_nan_probe_config_settles_like_any_other() {

        // FIXED (was "re_emits_reconfigure_on_every_frame"): the Reconfigure check uses

        // `PartialEq` on `GeolocationProbeConfig`, whose `max_accuracy_m` is an f32.

        // That PartialEq now compares by BIT PATTERN (see core/src/geolocation.rs), so a

        // NaN config equals itself and an *unchanged* config no longer looks drifted —

        // it settles after one Reconfigure instead of re-queuing every frame.

        let nan_cfg = probe_cfg(false, f32::NAN);

        let mut mgr = GeolocationManager::new();

        mgr.diff_layout(|emit| emit(nan_cfg));

        assert_eq!(mgr.take_pending_events().len(), 1, "the initial Subscribe");

        for _ in 0..3 {

            mgr.diff_layout(|emit| emit(nan_cfg));

            assert!(

                mgr.take_pending_events().is_empty(),

                "an unchanged NaN config must NOT re-queue a Reconfigure"

            );

        }

        // A sane config also settles immediately.

        mgr.diff_layout(|emit| emit(probe_cfg(false, 0.0)));

        assert_eq!(mgr.take_pending_events().len(), 1, "one Reconfigure to sane");

        mgr.diff_layout(|emit| emit(probe_cfg(false, 0.0)));

        assert!(mgr.take_pending_events().is_empty(), "then quiet");

    }

    #[test]

    fn extreme_probe_configs_survive_the_diff() {

        let extremes = [

            probe_cfg(true, f32::MAX),

            probe_cfg(false, f32::INFINITY),

            probe_cfg(true, -0.0),

            GeolocationProbeConfig {

                high_accuracy: true,

                background: true,

                max_accuracy_m: f32::MIN_POSITIVE,

                min_interval_ms: u32::MAX,

            },

        ];

        let mut mgr = GeolocationManager::new();

        for cfg in extremes {

            mgr.diff_layout(|emit| emit(cfg));

            assert_eq!(mgr.refcount(), 1);

            assert_eq!(mgr.active_config, Some(cfg));

            let events = mgr.take_pending_events();

            assert_eq!(events.len(), 1, "each distinct config emits exactly one event");

            match events[0] {

                GeolocationDiffEvent::Subscribe { config }

                | GeolocationDiffEvent::Reconfigure { config } => {

                    assert_eq!(config.max_accuracy_m.to_bits(), cfg.max_accuracy_m.to_bits());

                    assert_eq!(config.min_interval_ms, cfg.min_interval_ms);

                }

                GeolocationDiffEvent::Release => panic!("probes are mounted, not released"),

            }

        }

    }

    // ─────────────────────── equality invariants ────────────────────

    #[test]

    fn manager_equality_is_bit_blind_for_nan_fixes() {

        // The derived `PartialEq` on the manager inherits float semantics:

        // a manager holding a NaN-carrying fix is not even equal to its own

        // clone. Callers must not use `==` on the manager to detect movement

        // — that is what `set_latest_fix`'s return value is for.

        let mut with_nan = GeolocationManager::new();

        with_nan.set_latest_fix(nan_fix());

        assert_ne!(with_nan, with_nan.clone());

        let mut without_nan = GeolocationManager::new();

        without_nan.set_latest_fix(full_fix());

        assert_eq!(without_nan, without_nan.clone());

    }

}