use vec_arena::Arena;

#[test]
fn new() {
    let arena = Arena::<i32>::new();
    assert!(arena.is_empty());
    assert_eq!(arena.len(), 0);
    assert_eq!(arena.capacity(), 0);
}

#[test]
fn insert() {
    let mut arena = Arena::new();

    for i in 0..10 {
        assert_eq!(arena.insert(i * 10), i);
        assert_eq!(arena[i], i * 10);
    }
    assert!(!arena.is_empty());
    assert_eq!(arena.len(), 10);
}

#[test]
fn with_capacity() {
    let mut arena = Arena::with_capacity(10);
    assert_eq!(arena.capacity(), 10);

    for _ in 0..10 {
        arena.insert(());
    }
    assert_eq!(arena.len(), 10);
    assert_eq!(arena.capacity(), 10);

    arena.insert(());
    assert_eq!(arena.len(), 11);
    assert!(arena.capacity() > 10);
}

#[test]
fn remove() {
    let mut arena = Arena::new();

    assert_eq!(arena.insert(0), 0);
    assert_eq!(arena.insert(10), 1);
    assert_eq!(arena.insert(20), 2);
    assert_eq!(arena.insert(30), 3);
    assert_eq!(arena.len(), 4);

    assert_eq!(arena.remove(1), Some(10));
    assert_eq!(arena.remove(2), Some(20));
    assert_eq!(arena.len(), 2);

    assert!(arena.insert(-1) < 4);
    assert!(arena.insert(-1) < 4);
    assert_eq!(arena.len(), 4);

    assert_eq!(arena.remove(0), Some(0));
    assert!(arena.insert(-1) < 4);
    assert_eq!(arena.len(), 4);

    assert_eq!(arena.insert(400), 4);
    assert_eq!(arena.len(), 5);
}

#[test]
fn invalid_remove() {
    let mut arena = Arena::new();
    for i in 0..10 {
        arena.insert(i.to_string());
    }

    assert_eq!(arena.remove(7), Some("7".to_string()));
    assert_eq!(arena.remove(5), Some("5".to_string()));

    assert_eq!(arena.remove(!0), None);
    assert_eq!(arena.remove(10), None);
    assert_eq!(arena.remove(11), None);

    assert_eq!(arena.remove(5), None);
    assert_eq!(arena.remove(7), None);
}

#[test]
fn clear() {
    let mut arena = Arena::new();
    arena.insert(10);
    arena.insert(20);

    assert!(!arena.is_empty());
    assert_eq!(arena.len(), 2);

    let cap = arena.capacity();
    arena.clear();

    assert!(arena.is_empty());
    assert_eq!(arena.len(), 0);
    assert_eq!(arena.capacity(), cap);
}

#[test]
fn indexing() {
    let mut arena = Arena::new();

    let a = arena.insert(10);
    let b = arena.insert(20);
    let c = arena.insert(30);

    arena[b] += arena[c];
    assert_eq!(arena[a], 10);
    assert_eq!(arena[b], 50);
    assert_eq!(arena[c], 30);
}

#[test]
#[should_panic]
fn indexing_vacant() {
    let mut arena = Arena::new();

    let _ = arena.insert(10);
    let b = arena.insert(20);
    let _ = arena.insert(30);

    arena.remove(b);
    arena[b];
}

#[test]
#[should_panic]
fn invalid_indexing() {
    let mut arena = Arena::new();

    arena.insert(10);
    arena.insert(20);
    arena.insert(30);

    arena[100];
}

#[test]
fn get() {
    let mut arena = Arena::new();

    let a = arena.insert(10);
    let b = arena.insert(20);
    let c = arena.insert(30);

    *arena.get_mut(b).unwrap() += *arena.get(c).unwrap();
    assert_eq!(arena.get(a), Some(&10));
    assert_eq!(arena.get(b), Some(&50));
    assert_eq!(arena.get(c), Some(&30));

    arena.remove(b);
    assert_eq!(arena.get(b), None);
    assert_eq!(arena.get_mut(b), None);
}

#[test]
fn reserve() {
    let mut arena = Arena::new();
    arena.insert(1);
    arena.insert(2);

    arena.reserve(10);
    assert!(arena.capacity() >= 11);
}

#[test]
fn reserve_exact() {
    let mut arena = Arena::new();
    arena.insert(1);
    arena.insert(2);
    arena.reserve(10);
    assert!(arena.capacity() >= 11);
}

#[test]
fn iter() {
    let mut arena = Arena::new();
    let a = arena.insert(10);
    let b = arena.insert(20);
    let c = arena.insert(30);
    let d = arena.insert(40);

    arena.remove(b);

    let mut it = arena.iter();
    assert_eq!(it.next(), Some((a, &10)));
    assert_eq!(it.next(), Some((c, &30)));
    assert_eq!(it.next(), Some((d, &40)));
    assert_eq!(it.next(), None);
}

#[test]
fn iter_mut() {
    let mut arena = Arena::new();
    let a = arena.insert(10);
    let b = arena.insert(20);
    let c = arena.insert(30);
    let d = arena.insert(40);

    arena.remove(b);

    {
        let mut it = arena.iter_mut();
        assert_eq!(it.next(), Some((a, &mut 10)));
        assert_eq!(it.next(), Some((c, &mut 30)));
        assert_eq!(it.next(), Some((d, &mut 40)));
        assert_eq!(it.next(), None);
    }

    for (index, value) in &mut arena {
        *value += index;
    }

    let mut it = arena.iter_mut();
    assert_eq!(*it.next().unwrap().1, 10 + a);
    assert_eq!(*it.next().unwrap().1, 30 + c);
    assert_eq!(*it.next().unwrap().1, 40 + d);
    assert_eq!(it.next(), None);
}

#[test]
fn from_iter() {
    let arena: Arena<_> = [10, 20, 30, 40].iter().cloned().collect();

    let mut it = arena.iter();
    assert_eq!(it.next(), Some((0, &10)));
    assert_eq!(it.next(), Some((1, &20)));
    assert_eq!(it.next(), Some((2, &30)));
    assert_eq!(it.next(), Some((3, &40)));
    assert_eq!(it.next(), None);
}