use std::fmt;

// Error type
struct SparseSetError;

#[derive(Debug, Copy, Clone)]
struct DenseItem<T> {
    index: usize,
    value: T
}

// TODO: Use arrays+slices instead of vecs
#[derive(Debug)]
struct SparseSet<T> {
    sparse: Vec<Option<usize>>,
    dense: Vec<DenseItem<T>>
}

impl<T> SparseSet<T> {
    pub fn new() -> SparseSet<T> {
        SparseSet {
            sparse: vec![],
            dense: vec![]
        }
    }

    // Add an item to the dense vector and record its index in the sparse vector
    fn insert(&mut self, value: T) {
        let item = DenseItem {
            index: self.dense.len(),
            value: value
        };
        self.dense.push(item);
        let dense_index = self.dense.len() - 1;
        self.sparse.push(Some(dense_index));
    }

    // Remove an item at the supplied target index from the set
    // Replaces the selected target with the last item in the dense vector
    fn remove(&mut self, target_sparse_index: usize) -> Result<(), SparseSetError> {
        // Find the dense index of the target (need to decide what to do from there)
        let target_dense_index = self.sparse[target_sparse_index].unwrap();

        // If the target points to the last item in the dense set, this'll be easier
        if target_dense_index + 1 == self.dense.len() {
            // Remove the target from the dense set
            self.dense.pop();

            // Overwrite the target's sparse index
            self.sparse[target_sparse_index] = None;
        } else {
            // Get the last item in the dense set as a source to switch with
            // Change its index to the target sparse index, as it's replacing the target
            let source_item = match self.dense.pop() {
                Some(item) => { item },
                None => { return Err(SparseSetError) }
            };
    
            // Redirect the source item's sparse index to replace the target sparse index
            self.sparse[source_item.index] = Some(target_sparse_index);
    
            // Assign the source item to the target's place in the dense set
            self.dense[target_dense_index] = source_item;
    
            // Overwrite the target's sparse index
            self.sparse[target_dense_index] = None;
        }

        Ok(())
    }
}

fn main() {
    let mut test_set: SparseSet<f32> = SparseSet::new();
    test_set.insert(69.0);
    test_set.insert(420.0);
    test_set.insert(9001.0);
    println!("{:?}", test_set);
    test_set.remove(1);
    println!("{:?}", test_set);

    // Create a mutable array (contiguous memory!)
    let mut array: [Option<DenseItem<f32>>; 8] = [None; 8];

    // Create a mutable slice of that whole array
    let slice: &[Option<DenseItem<f32>>] = &mut array[..];

    for item in slice {
        println!("{:?}", item);
    }
}