//! Implement half of log rate-limiting: the ability to cause the state of a

//! Loggable to get flushed at appropriate intervals.

use super::{Activity, Loggable};

use futures::task::SpawnExt as _;

use std::{

    sync::{Arc, Mutex},

    time::Duration,

};

use tor_error::ErrorReport;

/// Declare a dyn-safe trait for the parts of an asynchronous runtime so that we

/// can install it globally.

pub(crate) mod rt {

    use futures::{future::BoxFuture, task::Spawn};

    use std::sync::OnceLock;

    use std::time::{Duration, Instant};

    /// A dyn-safe view of the parts of an async runtime that we need for rate-limiting.

    pub trait RuntimeSupport: Spawn + 'static + Sync + Send {

        /// Return a future that will yield () after `duration` has passed.

        fn sleep(&self, duration: Duration) -> BoxFuture<'_, ()>;

        /// Return the current time as an Instant.

        fn now(&self) -> Instant;

    }

    impl<R: tor_rtcompat::Runtime> RuntimeSupport for R {

    }

    /// A global view of our runtime, used for rate-limited logging.

    static RUNTIME_SUPPORT: OnceLock<Box<dyn RuntimeSupport>> = OnceLock::new();

    /// Try to install `runtime` as a global runtime to be used for rate-limited logging.

    ///

    /// Return an error (and make no changes) if there there was already a runtime installed.

    /// An error that occurs while installing a runtime.

    #[derive(Clone, Debug, thiserror::Error)]

    #[non_exhaustive]

    pub enum InstallRuntimeError {

        /// Tried to install a runtime when there was already one installed.

        #[error("Called tor_log_ratelim::install_runtime() more than once")]

        DuplicateCall,

    }

    /// Return the installed runtime, if there is one.

}

/// A rate-limited wrapper around a [`Loggable`]` that ensures its events are

/// flushed from time to time.

pub struct RateLim<T> {

    /// The Loggable itself.

    inner: Mutex<Inner<T>>,

}

/// The mutable state of a [`RateLim`].

struct Inner<T> {

    /// The loggable state whose reports are rate-limited

    loggable: T,

    /// True if we have a running task that is collating reports for `loggable`.

    task_running: bool,

}

impl<T: Loggable> RateLim<T> {

    /// Create a new `RateLim` to flush events for `loggable`.

    /// Adjust the status of this reporter's `Loggable` by calling `f` on it,

    /// but only if it is already scheduled to report itself.  Otherwise, do nothing.

    ///

    /// This is the appropriate function to use for tracking successes.f

    /// Add an event to this rate-limited reporter by calling `f` on it, and

    /// schedule it to be reported after an appropriate time.

    ///

    /// NOTE: This API is a big ugly. If we ever decide to make it non-hidden,

    /// we may want to make it call rt_support() directly again, as it did in

    /// earlier visions.

            // Launch a task to make periodic reports on the state of our Loggable.

                // We couldn't spawn a task; we have to flush the state

                // immediately.

                //

                // TODO: This behavior is undesirable if it causes us to spam

                // the log while we are shutting down.  On the other hand, it's

                // also undesirable if we suppress our logs while we're

                // shutting down.

}

/// After approximately this many seconds of not having anything to report, we

/// should reset our timeout schedule.

const RESET_AFTER_DORMANT_FOR: Duration = Duration::new(4 * 60 * 60, 0);

/// Return an iterator of reasonable amounts of time to summarize.

///

/// We summarize short intervals at first, and back off as the event keeps

/// happening.

    /// seconds per second.

    const SEC: u64 = 1;

    /// seconds per minute.

    const MIN: u64 = 60;

    /// seconds per hour

    const HOUR: u64 = 3600;

/// Helper: runs in a background task, and periodically flushes the `Loggable`

/// in `ratelim`.  Exits after [`Loggable::flush`] returns [`Activity::Dormant`]

/// for "long enough".

        {

            // NOTE: We say that we are summarizing "duration" on the theory

            // that we actually slept for "duration".  But maybe `sleep` slept

            // for a little more or less?  Nonetheless, we report this as if we

            // had slept for the exact amount, since the alternative appears to

            // be saying stuff like "this problem occurred 8/12 times in the

            // last 10min 0.0014ssec" instead of "10m".

                // TODO: This can tell the user several times that the problem

                // did not occur! Perhaps we only want to flush once on dormant,

                // and then not report the dormant condition again until we are

                // no longer tracking it.  Or perhaps we should lower the

                // responsibility for deciding when to log and when to uninstall

                // to the Loggable?

                    }

                }

        }

    }

// TODO : Write some tests.