struct PositionPermut {
    max_length: usize,
    number_of_digits: usize,
    idx: usize,
    total_number_of_iterations: usize,
}

impl Iterator for PositionPermut {
    type Item = Vec<i64>;

    fn next(&mut self) -> Option<Self::Item> {
        if self.idx == (self.total_number_of_iterations) {
            return None;
        };
        let pos1 = self.idx % self.number_of_digits;
        let pos0 = 0;
        let x = vec![pos0 as i64, pos1 as i64];
        let result = Some(x);
        self.idx += 1;
        result
    }
}

impl PositionPermut {
    fn new(max_length: usize) -> Self {
        assert!(max_length >= 3);
        let total_number_of_iterations = (1..max_length + 1).sum();
        Self {
            max_length,
            number_of_digits: 2,
            idx: 0,
            total_number_of_iterations,
        }
    }
    fn test(&mut self) {
        // length_of_numbers = 4
        // number_of_digits = 2
        [0, 1];
        [0, 2];
        [0, 3];
        [1, 2];
        [1, 3];
        [2, 3];
        // number_of_digits = 3
        [0, 1, 2];
        [0, 1, 3];
        [0, 2, 3];
        [1, 2, 3];
    }
}

#[cfg(test)]
mod test {
    #[test]
    fn test_permutation() {
        use crate::permutation::PositionPermut;
        use std::collections::HashSet;

        let permutator = PositionPermut::new(3);
        let result: HashSet<_> = permutator.into_iter().collect();
        let mut solution = HashSet::new();
        solution.insert(vec![0, 1]);
        solution.insert(vec![0, 2]);
        solution.insert(vec![0, 3]);
        solution.insert(vec![1, 2]);
        solution.insert(vec![1, 3]);
        solution.insert(vec![2, 3]);
        // solution.insert(vec![0, 1, 2]);
        // solution.insert(vec![0, 1, 3]);
        // solution.insert(vec![0, 2, 3]);
        // solution.insert(vec![1, 2, 3]);
        // assert_eq!(result.len(), solution.len());
        assert_eq!(result, solution);
    }
}