use rayon::prelude::*;
use std::collections::HashSet;

fn par_swap_remove<T>(v: &mut Vec<T>, indices: &Vec<usize>)
where
    T: Send + Sync + std::fmt::Debug + Clone,
{
    struct SafePtr<T: ?Sized>(*mut T);
    unsafe impl<T: ?Sized> Send for SafePtr<T> {}
    unsafe impl<T: ?Sized> Sync for SafePtr<T> {}

    if indices.len() == 0 {
        return;
    }

    // Exercise for the reader to validate the incomming parallel iterator

    let ptr = SafePtr(v.as_mut_ptr());

    println!("{:?} : Input", v);
    let mut i = 0;
    for i2 in (0..indices.len()).rev() {
        println!("Removing {}", indices[i2]);
        v.swap_remove(indices[i2]);
        println!("{:?} : After Remove", v);
        i = i2;
        if indices[i2] < v.len() - indices.len() {
            break;
        }
    }
    println!("==> Done with seq.");

    {
        let v2 = &v;
        indices[..i]
            .iter()
            .enumerate()
            .for_each(move |(i2, idx)| unsafe {
                let SafePtr(ptr) = ptr;

                let hole: *mut _ = ptr.add(*idx);
                println!("i  = {}", i);
                println!("i2 = {}", i2);
                println!("Swap {} <-> {}", idx, v2.len() - i2 - 1);
                let last = ptr.add(v2.len() - i2 - 1);
                std::ptr::swap(hole, last);
                println!("{:?} : After Remove", v2);
            });
    }
    println!(
        "len - indices.len() = {} - {} = {}",
        v.len(),
        indices.len(),
        v.len() - indices.len()
    );
    v.truncate(v.len() - indices.len() + indices.len() - i);
}

fn assert_same_set(a: &Vec<usize>, b: &Vec<usize>) {
    assert_eq!(
        a.iter().collect::<HashSet<_>>(),
        b.iter().collect::<HashSet<_>>(),
        "Should have same elements"
    );
}

fn main() {
    let mut v = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];
    let mut v2 = v.clone();
    let mut indices: Vec<usize> = vec![0, 1, 2, 4, 10, 9];
    indices.sort_by(|a, b| a.cmp(b));
    par_swap_remove(&mut v, &indices);

    for i in indices.iter().rev() {
        v2.swap_remove(*i);
    }

    assert_same_set(&v, &v2);
    println!("{:?} : Final", v);
    println!("{:?} : Final v2", v2);
}