extern crate smolset;

use smolset::{SetMode, SmolSet};
use std::fmt::Write;
use std::hash::{Hash, Hasher};
use std::iter::FromIterator;

#[test]
fn test_basic_set() {
    let mut s: SmolSet<[u32; 2]> = SmolSet::new();
    assert_eq!(s.insert(1), true);
    assert_eq!(s.insert(2), true);
    assert_eq!(s.insert(2), false);
    assert_eq!(s.insert(3), true);
    assert_eq!(s.insert(2), false);
    assert_eq!(s.insert(3), false);
    assert!(s.contains(&1));
    assert!(s.contains(&2));
    assert!(s.contains(&3));
    assert!(!s.contains(&4));
    let expected = vec![1, 2, 3];
    assert_eq!(s.len(), expected.len());
    assert!(s
        .iter()
        .map(|r| *r)
        .collect::<Vec<u32>>()
        .iter()
        .all(|x| expected.contains(x)));
    s.clear();
    assert!(!s.contains(&1));
}

#[test]
fn test_remove() {
    let mut s: SmolSet<[u32; 2]> = SmolSet::new();
    assert_eq!(s.insert(1), true);
    assert_eq!(s.insert(2), true);
    assert_eq!(s.len(), 2);
    assert!(s.contains(&1));
    assert_eq!(s.remove(&1), true);
    assert_eq!(s.remove(&1), false);
    assert_eq!(s.len(), 1);
    assert!(!s.contains(&1));
    assert_eq!(s.insert(1), true);
    let expected = vec![1, 2];
    assert_eq!(s.len(), expected.len());
    assert!(s
        .iter()
        .map(|r| *r)
        .collect::<Vec<u32>>()
        .iter()
        .all(|x| expected.contains(x)));
}

#[test]
fn test_clone() {
    let mut s: SmolSet<[u32; 2]> = SmolSet::new();
    s.insert(1);
    s.insert(2);
    let c = s.clone();
    assert!(c.contains(&1));
    assert!(c.contains(&2));
    assert!(!c.contains(&3));
}

#[test]
fn test_debug_small() {
    let mut s: SmolSet<[u32; 2]> = SmolSet::new();
    s.insert(1);
    s.insert(2);
    let mut buf = String::new();
    write!(buf, "{:?}", s).unwrap();
    assert_eq!(&buf, "[1, 2]");
}

#[test]
fn test_from_iter() {
    let s: SmolSet<[usize; 4]> = vec![1, 2, 3, 4].into_iter().collect();
    assert_eq!(s.len(), 4);
}

#[test]
fn test_into_iter() {
    let s: SmolSet<[usize; 4]> = vec![1, 2, 3, 4].into_iter().collect();
    let vec: Vec<_> = s.into_iter().collect();
    assert_eq!(vec.len(), 4)
}

#[test]
fn test_ref_into_iter() {
    let first: SmolSet<[usize; 4]> = vec![1, 2, 3, 4].into_iter().collect();
    let mut second = SmolSet::new();
    for item in &first {
        second.insert(*item);
    }
    assert_eq!(first, second);
}

#[test]
fn test_replace() {
    struct RingOf7 {
        pub value: u32,
    }

    impl PartialEq for RingOf7 {
        fn eq(&self, other: &Self) -> bool {
            self.value % 7 == other.value % 7
        }

        fn ne(&self, other: &Self) -> bool {
            self.value % 7 != other.value % 7
        }
    }

    impl From<RingOf7> for u32 {
        fn from(value: RingOf7) -> Self {
            value.value
        }
    }

    impl Hash for RingOf7 {
        fn hash<H: Hasher>(&self, state: &mut H) {
            self.value.hash(state)
        }
    }

    impl Eq for RingOf7 {}

    let mut lhs = SmolSet::<[RingOf7; 4]>::new();
    lhs.insert(RingOf7 { value: 1 });
    lhs.insert(RingOf7 { value: 2 });
    lhs.insert(RingOf7 { value: 3 });
    lhs.insert(RingOf7 { value: 4 });

    lhs.replace(RingOf7 { value: 8 });
    lhs.replace(RingOf7 { value: 9 });
    lhs.replace(RingOf7 { value: 10 });
    lhs.replace(RingOf7 { value: 11 });

    let expected = vec![8, 9, 10, 11];
    assert_eq!(lhs.len(), expected.len());
    assert!(lhs
        .iter()
        .map(|x| x.value)
        .collect::<Vec<u32>>()
        .iter()
        .all(|x| expected.contains(x)));
}

#[test]
fn test_eq_both_stack() {
    let mut lhs = SmolSet::<[u32; 4]>::new();
    lhs.insert(1);
    lhs.insert(2);

    let mut rhs = SmolSet::<[u32; 4]>::new();
    rhs.insert(1);
    rhs.insert(2);

    assert_eq!(lhs, rhs);
}

#[test]
fn test_eq_both_heap() {
    let expected = (0..100).collect::<Vec<u32>>();
    let lhs = SmolSet::<[u32; 4]>::from_iter(expected.clone());
    let rhs = SmolSet::<[u32; 4]>::from_iter(expected.clone());

    assert_eq!(lhs, rhs);
}

#[test]
fn test_eq_stack_heap() {
    let expected = (0..5).collect::<Vec<u32>>();
    let mut lhs = SmolSet::<[u32; 10]>::from_iter(expected.clone());
    let rhs = SmolSet::<[u32; 10]>::from_iter(expected.clone());

    (100..200).for_each(|x| assert!(lhs.insert(x)));
    (100..200).for_each(|x| assert!(lhs.remove(&x)));

    assert_eq!(lhs.mode(), SetMode::Heap);
    assert_eq!(rhs.mode(), SetMode::Stack);

    assert_eq!(lhs, rhs);
}

#[test]
fn test_intersection() {
    let mut lhs = SmolSet::<[u32; 4]>::new();
    lhs.insert(1);
    lhs.insert(3);
    lhs.insert(5);
    lhs.insert(4);
    lhs.insert(8);
    lhs.insert(10);

    let mut rhs = SmolSet::<[u32; 4]>::new();
    rhs.insert(4);
    rhs.insert(8);
    rhs.insert(10);

    assert!(lhs.intersection(&rhs).all(|x| x % 2 == 0));
}

#[test]
fn test_union() {
    let mut lhs = SmolSet::<[u32; 4]>::new();
    lhs.insert(1);
    lhs.insert(2);
    lhs.insert(3);
    lhs.insert(4);

    let mut rhs = SmolSet::<[u32; 4]>::new();
    rhs.insert(3);
    rhs.insert(4);
    rhs.insert(5);
    rhs.insert(6);

    let union = lhs.union(&rhs).collect::<Vec<_>>();
    let expected = vec![1, 2, 3, 4, 5, 6];
    assert_eq!(union.len(), expected.len());
    assert!(expected
        .iter()
        .collect::<Vec<&u32>>()
        .iter()
        .all(|x| union.contains(x)));
}

#[test]
fn test_difference() {
    let mut lhs = SmolSet::<[u32; 4]>::new();
    lhs.insert(1);
    lhs.insert(2);
    lhs.insert(3);
    lhs.insert(4);

    let mut rhs = SmolSet::<[u32; 4]>::new();
    rhs.insert(3);
    rhs.insert(4);
    rhs.insert(5);
    rhs.insert(6);

    let union = lhs.difference(&rhs).collect::<Vec<_>>();
    let expected = vec![1, 2];
    assert_eq!(union.len(), expected.len());
    assert!(expected
        .iter()
        .collect::<Vec<&u32>>()
        .iter()
        .all(|x| union.contains(x)));
}

#[test]
fn test_symmetric_difference() {
    let mut lhs = SmolSet::<[u32; 4]>::new();
    lhs.insert(1);
    lhs.insert(2);
    lhs.insert(3);
    lhs.insert(4);

    let mut rhs = SmolSet::<[u32; 4]>::new();
    rhs.insert(3);
    rhs.insert(4);
    rhs.insert(5);
    rhs.insert(6);

    let symmetric_difference = lhs.symmetric_difference(&rhs).collect::<Vec<_>>();
    let expected = vec![1, 2, 5, 6];
    assert_eq!(symmetric_difference.len(), expected.len());
    assert!(expected
        .iter()
        .collect::<Vec<&u32>>()
        .iter()
        .all(|x| { symmetric_difference.contains(x) }));
}