//! The hybrid logical clock on every event (spec §9.1), with Oxygen's drift

//! bound (oxygen spec §6.4): observing a remote time never moves this clock

//! more than five minutes ahead of the local wall clock.

use std::sync::Mutex;

/// How far ahead of the local clock an observed time may move ours.

pub const MAX_DRIFT_MS: u64 = 5 * 60 * 1000;

/// A hybrid logical clock reading: wall milliseconds and a counter.

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

pub struct Hlc {

    pub wall_ms: u64,

    pub logical: u32,

}

/// The clock: monotonic across calls, whatever the wall clock does.

#[derive(Debug, Default)]

pub struct Clock {

    last: Mutex<Hlc>,

}

impl Clock {

    /// A clock that continues from `last` (the ledger's newest reading).

    pub fn starting_at(last: Hlc) -> Clock {

        Clock { last: Mutex::new(last) }

    }

    /// The next reading for a local event, at wall time `now_ms`.

    pub fn tick(&self, now_ms: u64) -> Hlc {

        let mut last = self.last.lock().unwrap();

        *last = if now_ms > last.wall_ms {

            Hlc { wall_ms: now_ms, logical: 0 }

        } else {

            Hlc { wall_ms: last.wall_ms, logical: last.logical.saturating_add(1) }

        };

        *last

    }

    /// Take a remote reading into account, as on receiving another

    /// Spectra's event; the remote reading is kept as it is, only this

    /// clock's own advance is bounded.

    pub fn observe(&self, remote: Hlc, now_ms: u64) {

        let mut last = self.last.lock().unwrap();

        let bound = now_ms.saturating_add(MAX_DRIFT_MS);

        let remote = if remote.wall_ms > bound { Hlc { wall_ms: bound, logical: 0 } } else { remote };

        if remote > *last {

            *last = remote;

        }

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn ticks_are_monotonic_when_the_wall_clock_stalls_or_steps_back() {

        let c = Clock::default();

        let a = c.tick(1_000);

        let b = c.tick(1_000);

        let d = c.tick(500);

        assert!(a < b && b < d);

        assert_eq!(c.tick(2_000), Hlc { wall_ms: 2_000, logical: 0 });

    }

    #[test]

    fn a_far_future_remote_time_moves_the_clock_by_the_drift_bound_at_most() {

        let c = Clock::default();

        c.observe(Hlc { wall_ms: 10_000_000_000, logical: 7 }, 1_000);

        assert_eq!(c.tick(1_000).wall_ms, 1_000 + MAX_DRIFT_MS);

    }

}