//! Declaration for an n-keyed set type, allowing access to each of its members by each of N different keys.

// Re-export dependencies that we use to make this macro work.

#[doc(hidden)]

pub mod deps {

    pub use paste::paste;

    pub use slab::Slab;

}

/// Declare a structure that can hold elements with multiple unique keys.

///

/// Each element can be looked up or removed by any of its keys. The keys

/// themselves can be any type that supports `Hash`, `Eq`, and `Clone`. Elements

/// can have multiple keys of the same type: for example, a person can have a

/// username `String` and an irc_handle `String`.

///

/// All keys in the set must be unique: if a new element is inserted that has

/// the same value for any key as a previous element, the old element is

/// removed.

///

/// Keys may be accessed from elements either by field access or by an accessor

/// function.

///

/// Keys may be optional.  If all keys are optional, then we require

/// additionally that every element must have at least one key.

///

/// # Examples

///

/// ```

/// use tor_basic_utils::n_key_set;

///

/// // We declare a person struct with several different fields.

/// pub struct Person {

///     username: String,

///     irc_handle: String,

///     student_id: Option<u64>,

///     favorite_joke: Option<String>,

/// }

///

/// n_key_set! {

///     pub struct PersonSet for Person {

///         // See note on "Key syntax" below.  The ".foo" syntax

///         // here means that the value for the key is returned

///         // by accessing a given field.

///         username: String { .username },

///         irc_handle: String { .irc_handle },

///         (Option) student_id: u64 { .student_id }

///     }

/// }

///

/// let mut people = PersonSet::new();

/// people.insert(Person {

///     username: "mina".into(),

///     irc_handle: "pashMina".into(),

///     student_id: None,

///     favorite_joke: None

/// });

/// assert!(people.by_username("mina").is_some());

/// assert!(people.by_irc_handle("pashMina").is_some());

/// ```

///

/// # Key syntax

///

/// You can tell the map to access the keys of an element in any of several ways.

///

/// * `name : type { func() }` - A key whose name is `name` and type is `type`,

///   that can be accessed from a given element by calling `element.func()`.

/// * `name : type { .field }` - A key whose name is `name` and type is `type`,

///   that can be accessed from a given element by calling `&element.field`.

/// * `name : type` - Short for as `name : type { name() }`.

///

/// If a key declaration is preceded with `(Option)`, then the

/// key is treated as optional, and accessor functions are expected to return

/// `Option<&Type>`.

///

/// # Additional features

///

/// You can put generic parameters and `where` constraints on your structure.

/// The `where` clause (if present) must be wrapped in square brackets.

///

/// If you need to use const generics or lifetimes in your structure, you

/// need to use square brackets instead of angle brackets, and specify both the

/// generic parameters *and* the type that you are implementing. (This is due to

/// limitations in the Rust macro system.)  For example:

///

/// ```

/// # use tor_basic_utils::n_key_set;

/// n_key_set!{

///     struct['a, T, const N: usize] ArrayMap2['a, T, N] for (String, [&'a T;N])

///         [ where T: Clone + 'a ]

///     {

///          name: String { .0 }

///     }

/// }

/// ```

#[macro_export]

macro_rules! n_key_set {

{

    $(#[$meta:meta])*

    $vis:vis struct $mapname:ident $(<$($P:ident),*>)? for $V:ty

    $( where [ $($constr:tt)+ ] )?

    {

        $($body:tt)+

    }

} => {

n_key_set!{

    $(#[$meta])*

    $vis struct [$($($P),*)?] $mapname [$($($P),*)?] for $V

    $( [ where $($constr)+ ] )?

    {

        $( $body )+

    }

}

};

{

        $(#[$meta:meta])*

        $vis:vis struct [$($($G:tt)+)?] $mapname:ident [$($($P:tt)+)?] for $V:ty

        $( [ where $($constr:tt)+ ])?

        {

            $( $(( $($flag:ident)+ ))? $key:ident : $KEY:ty $({ $($source:tt)+ })? ),+

            $(,)?

        }

} => {

$crate::n_key_set::deps::paste!{

   $( #[$meta] )*

    #[doc = concat!(

        "A set of elements of type ", stringify!($V), " whose members can be accessed by multiple keys.",

        "\n\nThe keys are:",

        $( " * `", stringify!($key), "` (`",stringify!($KEY),"`)\n" ,

           $(" (", stringify!($($flag)+), ")", )?

         )+

        "\

Each member has a value for *each* required key, and up to one value

for *each* optional key.

The set contains at most one member for any value of a given key.

# Requirements

Key types must have consistent `Hash` and `Eq` implementations, as

they will be used as keys in a `HashMap`.

If all keys are optional, then every element in this set

must have at least one non-None key.

An element must not change its keys over time through interior

mutability.

⚠️ If *any* of these rules is violated, the consequences are unspecified,

and could include panics or wrong answers (but not memory-unsafety).

# Limitations

This could be more efficient in space and time.

        ",

    )]

            #![allow(noop_method_call)] // permit borrow when it does nothing.

            use std::borrow::Borrow;

            // Make sure that every entry in the $key map points to a

            // value with the right value for that $key.

            $(

                    )

                }

            )+

            // Make sure that every value has an entry in the $key map that

            // points to it, for each of its keys.

            //

            // This is slightly redundant, but we don't care too much about

            // efficiency here.

                $(

                    )

            }

    }

    impl $(<$($G)*>)? Default for $mapname $(<$($P)*>)?

        where $( $KEY : std::hash::Hash + Eq + Clone , )*  $($($constr)+)?

    {

    }

    impl $(<$($G)*>)? FromIterator<$V> for $mapname $(<$($P)*>)?

        where $( $KEY : std::hash::Hash + Eq + Clone , )*  $($($constr)+)?

    {

    }

}

};

// Helper: Generate an expression to access a specific key and return

// an Option<&TYPE> for that key.  This is the part of the macro

// that parses key descriptions.

{ @access($ex:expr, (Option) $key:ident : $t:ty ) } => {

    $ex.key()

};

{ @access($ex:expr, () $key:ident : $t:ty) } => {

    Some($ex.key())

};

{ @access($ex:expr, (Option) $key:ident : $t:ty { . $field:tt } ) } => {

    $ex.$field.as_ref()

};

{ @access($ex:expr, () $key:ident : $t:ty { . $field:tt } ) } => {

   Some(&$ex.$field)

};

{ @access($ex:expr, (Option) $key:ident : $t:ty { $func:ident () } ) } => {

    $ex.$func()

};

{ @access($ex:expr, () $key:ident : $t:ty { $func:ident () } ) } => {

    Some($ex.$func())

};

}

/// An error returned from an operation on an `n_key_set`.

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

#[non_exhaustive]

pub enum Error {

    /// We tried to insert a value into a set where all keys were optional, but

    /// every key on that value was `None`.

    #[error("Tried to insert a value with no keys")]

    NoKeys,

}

#[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 @@ -->

    n_key_set! {

        #[derive(Clone, Debug)]

        struct Tuple2Set<A,B> for (A,B) {

            first: A { .0 },

            second: B { .1 },

        }

    }

    #[test]

    fn basic() {

        let mut set = Tuple2Set::new();

        assert!(set.is_empty());

        set.insert((0_u32, 99_u16));

        assert_eq!(set.contains_first(&0), true);

        assert_eq!(set.contains_second(&99), true);

        assert_eq!(set.contains_first(&99), false);

        assert_eq!(set.contains_second(&0), false);

        assert_eq!(set.by_first(&0), Some(&(0, 99)));

        assert_eq!(set.by_second(&99), Some(&(0, 99)));

        assert_eq!(set.by_first(&99), None);

        assert_eq!(set.by_second(&0), None);

        assert_eq!(set.insert((12, 34)), vec![]);

        assert_eq!(set.len(), 2);

        assert!(set.capacity() >= 2);

        assert_eq!(set.by_first(&0), Some(&(0, 99)));

        assert_eq!(set.by_first(&12), Some(&(12, 34)));

        assert_eq!(set.remove_by_second(&99), Some((0, 99)));

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

        // no overlap in these next few inserts.

        set.insert((34, 56));

        set.insert((56, 78));

        set.insert((78, 90));

        assert_eq!(set.len(), 4);

        // This insert replaces (12, 34)

        assert_eq!(set.insert((12, 123)), vec![(12, 34)]);

        // This one replaces (12,123) and (34,56).

        let mut replaced = set.insert((12, 56));

        replaced.sort();

        assert_eq!(replaced, vec![(12, 123), (34, 56)]);

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

        assert_eq!(set.is_empty(), false);

        set.check_invariants();

        // Test our iterators

        let mut all_members: Vec<_> = set.values().collect();

        all_members.sort();

        assert_eq!(all_members, vec![&(12, 56), &(56, 78), &(78, 90)]);

        let mut drained_members: Vec<_> = set.into_values().collect();

        drained_members.sort();

        assert_eq!(drained_members, vec![(12, 56), (56, 78), (78, 90)]);

    }

    #[test]

    fn retain_and_compact() {

        let mut set: Tuple2Set<String, String> = (1..=1000)

            .map(|idx| (format!("A={}", idx), format!("B={}", idx)))

            .collect();

        assert_eq!(set.len(), 1000);

        let cap_orig = set.capacity();

        assert!(cap_orig >= set.len());

        // Retain only the values whose first key is 3 characters long.

        // That's 9 values out of 1000.

        set.retain(|(a, _)| a.len() <= 3);

        assert_eq!(set.len(), 9);

        // We don't shrink till we next insert.

        assert_eq!(set.capacity(), cap_orig);

        set.check_invariants();

        assert!(set

            .insert(("A=0".to_string(), "B=0".to_string()))

            .is_empty());

        assert!(set.capacity() < cap_orig);

        assert_eq!(set.len(), 10);

        for idx in 0..=9 {

            assert!(set.contains_first(&format!("A={}", idx)));

        }

        set.check_invariants();

    }

    #[test]

    fn modify_value() {

        let mut set: Tuple2Set<i32, i32> = (1..=100).map(|idx| (idx, idx * idx)).collect();

        set.check_invariants();

        let v = set.modify_by_first(&30, |elt| elt.1 = 256);

        set.check_invariants();

        // one element was replaced.

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

        assert_eq!(v[0], (16, 256));

        assert_eq!(set.by_second(&256).unwrap(), &(30, 256));

        assert_eq!(set.by_first(&30).unwrap(), &(30, 256));

        let v = set.modify_by_first(&30, |elt| *elt = (-100, -100));

        set.check_invariants();

        // no elements were replaced.

        assert_eq!(v.len(), 0);

        assert_eq!(set.by_first(&30), None);

        assert_eq!(set.by_second(&256), None);

        assert_eq!(set.by_first(&-100).unwrap(), &(-100, -100));

        assert_eq!(set.by_second(&-100).unwrap(), &(-100, -100));

        set.check_invariants();

    }

    #[allow(dead_code)]

    struct Weekday {

        dow: u8,

        name: &'static str,

        lucky_number: Option<u16>,

    }

    #[allow(dead_code)]

    impl Weekday {

        // TODO: I wish this could return u8

        fn dow(&self) -> &u8 {

            &self.dow

        }

        fn name(&self) -> &str {

            self.name

        }

        // TODO: I wish this could return Option<u16>

        fn lucky_number(&self) -> Option<&u16> {

            self.lucky_number.as_ref()

        }

    }

    n_key_set! {

        struct WeekdaySet for Weekday {

            idx: u8 { dow() },

            (Option) lucky: u16 { lucky_number() },

            name: String { name() }

        }

    }

    n_key_set! {

        struct['a] ArrayMap['a] for (String, [&'a u32;10]) {

            name: String { .0 }

        }

    }

    n_key_set! {

        struct['a, const N:usize] ArrayMap2['a, N] for (String, [&'a u32;N]) {

            name: String { .0 }

        }

    }

}