//! An internal pool object that we use to implement HsCircPool.

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

use crate::{

    hspool::{HsCircStem, HsCircStemKind},

    AbstractCirc,

};

use rand::Rng;

use tor_basic_utils::RngExt as _;

/// A collection of circuits used to fulfil onion-service-related requests.

pub(super) struct Pool<C: AbstractCirc> {

    /// The collection of circuits themselves, in no particular order.

    circuits: Vec<HsCircStem<C>>,

    /// The number of NAIVE elements that we would like to have in our pool.

    stem_target: usize,

    /// The number of GUARDED elements that we would like to have in our pool.

    guarded_stem_target: usize,

    /// True if we have exhausted our pool since the last time we decided

    /// whether to change our target level.

    have_been_exhausted: bool,

    /// True if we have been under 4/5 of our target since the last time we

    /// decided whether to change it.

    have_been_under_highwater: bool,

    /// Last time when we changed our target size.

    last_changed_target: Option<Instant>,

}

/// Our default (and minimum) target NAIVE pool size.

const DEFAULT_NAIVE_STEM_TARGET: usize = 3;

/// Our default (and minimum) target GUARDED pool size.

const DEFAULT_GUARDED_STEM_TARGET: usize = 1;

/// Our maximum target NAIVE pool size.  We will never let our NAIVE target grow above this

/// value.

const MAX_NAIVE_STEM_TARGET: usize = 384;

/// Our maximum target GUARDED pool size.  We will never let our GUARDED target grow above this

/// value.

const MAX_GUARDED_STEM_TARGET: usize = 128;

/// A type of circuit we would like to launch.

///

/// [`ForLaunch::note_circ_launched`] should be called whenever a circuit

/// of this [`HsCircStemKind`] is launched, to decrement the internal target `count`.

pub(super) struct ForLaunch<'a> {

    /// The kind of circuit we want to launch.

    kind: HsCircStemKind,

    /// How many circuits of this kind do we need?

    ///

    /// This is a mutable reference to one of the target values from [`CircsToLaunch`];

    /// we decrement it when we have launched a circuit of this type.

    count: &'a mut usize,

}

impl<'a> ForLaunch<'a> {

    /// A circuit was launched, decrement the current target for its kind.

    /// The kind of circuit we want to launch.

}

/// The circuits we need to launch.

pub(super) struct CircsToLaunch {

    /// The number of NAIVE circuits we want to launch.

    stem_target: usize,

    /// The number of GUARDED circuits we want to launch.

    guarded_stem_target: usize,

}

impl CircsToLaunch {

    /// Return a [`ForLaunch`] representing a circuit we would like to launch.

        } else {

            // If we have enough NAIVE circuits, we can start launching GUARDED ones too.

        }

    /// Return the number of NAIVE circuits we would like to launch.

    /// Return the number of GUARDED circuits we would like to launch.

    /// Return the total number of circuits we would currently like to launch.

}

impl<C: AbstractCirc> Default for Pool<C> {

}

impl<C: AbstractCirc> Pool<C> {

    /// Add `circ` to this pool

    /// Remove every circuit from this pool for which `f` returns false.

    /// Return true if we are very low on circuits and should build more immediately.

    /// Return a [`CircsToLaunch`] describing the circuits we would currently like to launch.

    /// Return the number of NAIVE circuits we would currently like to launch.

    /// Return the number of GUARDED circuits we would currently like to launch.

    /// Return the total number of circuits we would like to launch.

    ///

    /// We do not discard when we are _above_ this threshold, but we do

    /// try to build when we are low.

    /// If there is any circuit in this pool for which `f`  returns true and that satisfies

    /// all of the specified [`HsCircPrefs`], return one such circuit at random, and remove

    /// it from the pool.

    ///

    /// If none of the circuits satisfy `prefs`, return a randomly selected circuit for which `f`

    /// returns true, and remove it from the pool.

        };

    /// Update the target sizes for our pool.

    ///

    /// This updates our target numbers of NAIVE and GUARDED circuits.

        /// Minimum amount of time that must elapse between a change and a

        /// decision to grow our pool.  We use this to control the rate of

        /// growth and make sure that we are allowing enough time for circuits

        /// to complete.

        const MIN_TIME_TO_GROW: Duration = Duration::from_secs(120);

        /// Minimum amount of time that must elapse between a target change and

        /// a decisions to shrink our target.  We use this to make sure that we

        /// aren't shrinking too rapidly, and that we are allowing enough time

        /// for the pool to actually get used.

        const MIN_TIME_TO_SHRINK: Duration = Duration::from_secs(600);

    /// Purge all the circuits from the pool.

    #[allow(clippy::unnecessary_wraps)] // for consistency and future-proofing

}

/// Preferences for what kind of circuit to select from the pool.

#[derive(Default, Debug, Clone)]

pub(super) struct HsCircPrefs {

    /// If `Some`, specifies the [`HsCircStemKind`] we would like.

    pub(super) kind_prefs: Option<HsCircStemKind>,

}

impl HsCircPrefs {

    /// Set the preferred [`HsCircStemKind`].

}

/// Helper: find a random item `elt` in `slice` such that `predicate(elt)` is

/// true. Return the index of that item.

///

/// Can arbitrarily reorder `slice`. This allows us to visit the indices in uniform-at-random

/// order, without having to do any O(N) operations or allocations.

    }

    // We didn't find any.

#[cfg(test)]

mod test {

    // @@ begin test lint list maintained by maint/add_warning @@

    #![allow(clippy::bool_assert_comparison)]

    #![allow(clippy::clone_on_copy)]

    #![allow(clippy::dbg_macro)]

    #![allow(clippy::mixed_attributes_style)]

    #![allow(clippy::print_stderr)]

    #![allow(clippy::print_stdout)]

    #![allow(clippy::single_char_pattern)]

    #![allow(clippy::unwrap_used)]

    #![allow(clippy::unchecked_duration_subtraction)]

    #![allow(clippy::useless_vec)]

    #![allow(clippy::needless_pass_by_value)]

    //! <!-- @@ end test lint list maintained by maint/add_warning @@ -->

    use super::*;

    use tor_basic_utils::test_rng::testing_rng;

    #[test]

    fn random_idx() {

        let mut rng = testing_rng();

        let mut orig_numbers: Vec<i32> = vec![1, 3, 4, 8, 11, 19, 12, 6, 27];

        let mut numbers = orig_numbers.clone();

        let mut found: std::collections::HashMap<i32, bool> =

            numbers.iter().map(|n| (*n, false)).collect();

        for _ in 0..1000 {

            let idx = random_idx_where(&mut rng, &mut numbers[..], |n| n & 1 == 1).unwrap();

            assert!(numbers[idx] & 1 == 1);

            found.insert(numbers[idx], true);

        }

        for num in numbers.iter() {

            assert!(found[num] == (num & 1 == 1));

        }

        // Number may be reordered, but should still have the same elements.

        numbers.sort();

        orig_numbers.sort();

        assert_eq!(numbers, orig_numbers);

    }

    #[test]

    fn random_idx_empty() {

        let mut rng = testing_rng();

        let idx = random_idx_where(&mut rng, &mut [], |_: &i32| panic!());

        assert_eq!(idx, None);

    }

    #[test]

    fn random_idx_none() {

        let mut rng = testing_rng();

        let mut numbers: Vec<i32> = vec![1, 3, 4, 8, 11, 19, 12, 6, 27];

        assert_eq!(

            random_idx_where(&mut rng, &mut numbers[..], |_: &i32| false),

            None

        );

    }

}