use core::panic;

use std::fmt;

use std::hash::BuildHasher;

use std::hash::Hash;

use std::ops::Deref;

use std::ops::Index;

use std::ops::IndexMut;

use hashbrown::Equivalent;

use hashbrown::HashTable;

use rustc_hash::FxBuildHasher;

use merc_utilities::GenerationCounter;

use merc_utilities::GenerationalIndex;

use merc_utilities::cast;

/// A type-safe index for use with [IndexedSet]. Uses generational indices in debug builds to assert

/// correct usage of indices.

#[repr(transparent)]

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

pub struct SetIndex(GenerationalIndex<usize>);

impl Deref for SetIndex {

    type Target = usize;

}

impl fmt::Debug for SetIndex {

}

impl fmt::Display for SetIndex {

}

/// A set that assigns a unique index to every entry. The returned index can be used to access the inserted entry.

pub struct IndexedSet<T, S = FxBuildHasher> {

    /// The table of elements, which can be either filled or empty.

    table: Vec<IndexSetEntry<T>>,

    /// Indexes of the elements in the set. Stores only the index; the hash is recomputed via the

    /// stored `hasher` on lookup using [`HashTable`]'s explicit-hash API.

    index: HashTable<usize>,

    /// A list of free nodes, where the value is the first free node.

    free: Option<usize>,

    /// The number of generations

    generation_counter: GenerationCounter,

    /// The hasher used to compute hashes for elements

    hasher: S,

}

/// An entry in the indexed set, which can either be filled or empty.

enum IndexSetEntry<T> {

    Filled(T),

    Empty(usize),

}

impl<T, S: BuildHasher + Default> IndexedSet<T, S> {

    /// Creates a new empty IndexedSet with the default hasher.

}

impl<T, S> IndexedSet<T, S> {

    /// Creates a new empty IndexedSet with the specified hasher.

    /// Returns the number of elements in the set.

    /// Returns true if the set is empty.

    /// Returns a reference to the element at the given index, if it exists.

            }

        } else {

        }

    /// Returns a reference to the element at the given raw table index, if a

    /// filled entry exists there.

    ///

    /// Unlike [Self::get] this takes a plain `usize` and performs no generation

    /// check; it only verifies that the slot is in bounds and filled.

            }

        } else {

        }

    /// Returns the capacity of the set.

    /// Returns an iterator over the elements in the set.

}

impl<T: Clone, S> IndexedSet<T, S> {

    /// Returns a vector containing all elements of this indexed set.

}

impl<T: Hash + Eq, S: BuildHasher> IndexedSet<T, S> {

    /// Inserts the given element into the set

    ///

    /// Returns the corresponding index and a boolean indicating if the element was inserted.

    {

            // The element is already in the set, so return the index.

    /// Inserts the given element into the set

    ///

    /// Returns the corresponding index and a boolean indicating if the element was inserted.

            // The element is already in the set, so return the index.

    /// Returns the index for the given element, or None if it does not exist.

    {

    /// Erases all elements for which f(index, element) returns false. Allows

    /// modifying the given element (as long as the hash/equality does not change).

    {

            {

                };

        }

    /// Removes the given element from the set.

            };

        } else {

            // The element was not found in the set.

        }

    /// Removes all elements in this indexed set.

    /// Returns true iff the set contains the given element.

    {

    /// Inserts `value` into the `table`, reusing a free slot if one is available, and returns

    /// its index. Does not modify the secondary hash index.

                };

            }

            None => {

                // No free positions so insert new.

            }

        }

}

impl<T, S> fmt::Debug for IndexedSet<T, S>

where

    T: fmt::Debug,

{

}

impl<T, S: BuildHasher + Default> Default for IndexedSet<T, S> {

}

impl<T, S> Index<SetIndex> for IndexedSet<T, S> {

    type Output = T;

        // Go through the generation counter so a stale index is detected in

        // debug builds, consistent with [Self::get].

}

impl<T, S: BuildHasher> IndexMut<SetIndex> for IndexedSet<T, S> {

        // Go through the generation counter so a stale index is detected in

        // debug builds, consistent with [Self::get].

}

/// Returns whether the element stored at `table[index]` is equivalent to `value`.

///

/// Returns `false` for free slots, which should never appear in the secondary hash index.

    }

/// Computes the hash of the filled element stored at `table[index]` using `hasher`.

///

/// Used as the rehasher callback for [`HashTable`] operations.

    }

/// An iterator over the elements in the IndexedSet.

pub struct Iter<'a, T, S> {

    reference: &'a IndexedSet<T, S>,

    index: usize,

    generation_counter: &'a GenerationCounter,

}

impl<'a, T, S> Iterator for Iter<'a, T, S> {

    type Item = (SetIndex, &'a T);

        }

}

impl<'a, T, S> IntoIterator for &'a IndexedSet<T, S> {

    type Item = (SetIndex, &'a T);

    type IntoIter = Iter<'a, T, S>;

}

#[cfg(test)]

mod tests {

    use rand::RngExt;

    use std::collections::HashMap;

    use merc_utilities::random_test;

    use crate::IndexedSet;

    use crate::SetIndex;

    #[test]

            // Insert several elements and keep track of the resulting indices.

            // Check if the indices match the previously stored ones.

                    "The resulting index does not match the returned value"

                );

            }

            // Remove some elements from the set.

            // Check consistency of the indexed set after removals.

                    "The resulting index does not match the returned value"

                );

            }

                    "Index {} should still match element {:?}",

                    *index,

                    value

                );

            }

            // Check the contains function

                    contains,

                    "The contains function returned an incorrect result for value {:?}",

                    value

                );

            }

}