use std::{collections::HashSet, hash::Hash};

/// 集合相关工具类，如交并集、反转、移除元素等
pub struct CollectionUtil;

/// vec常规操作
impl CollectionUtil { 

    /// 获取vec的第一个元素，不移除
    pub fn first<'a, T>(vec: &'a Vec<T>) -> Option<&'a T> { 
        if vec.len() > 0 { vec.get(0) } else { None }
    }

    /// 移除并获取vec的第一个元素
    pub fn remove_first<T>(vec: &mut Vec<T>) -> Option<T> { 
        if vec.len() > 0 { Some(vec.remove(0)) } else { None }
    }

    /// 获取vec的最后一个元素，不移除
    pub fn last<'a, T>(vec: &'a Vec<T>) -> Option<&'a T> { 
        vec.last()
    }
    
    /// 获取vec的最后一个元素，移除
    pub fn pop<T>(vec: &mut Vec<T>) -> Option<T> { 
        vec.pop()
    }

    /// 反转向量中的元素顺序
    pub fn reverse<T>(vec: &mut Vec<T>) { 
        vec.reverse()
    }

    /// 移除重复的元素
    pub fn distinct<T: Eq + Hash + Clone>(vec: &Vec<T>) -> Vec<T> { 
        let mut hash_set = HashSet::new();
        for item in vec.iter() {
            hash_set.insert(item.clone());
        }
        hash_set.into_iter().collect()
    }

    /// 计算交集：两个集合中都存在的元素
    pub fn intersection<T>(vec1: Vec<T>, vec2: Vec<T>) -> Vec<T>
    where T: Eq + Hash + Clone {
        // 转换为HashSet
        let set1: HashSet<T> = vec1.into_iter().collect();
        let set2: HashSet<T> = vec2.into_iter().collect();
        // 计算交集：两个集合中都存在的元素
        let result: Vec<T> = set1.intersection(&set2).cloned().collect();
        result
    }

    /// 计算并集：两个集合中所有不重复的元素
    pub fn union<T>(vec1: Vec<T>, vec2: Vec<T>) -> Vec<T>
    where T: Eq + Hash + Clone {
        let set1: HashSet<T> = vec1.into_iter().collect();
        let set2: HashSet<T> = vec2.into_iter().collect();
        // 计算并集：两个集合中所有不重复的元素
        let result: Vec<_> = set1.union(&set2).cloned().collect();
        result
    }

    /// 计算差集：set1中有而set2中没有的元素
    pub fn difference<T>(vec1: Vec<T>, vec2: Vec<T>) -> Vec<T>
    where T: Eq + Hash + Clone {
        let set1: HashSet<T> = vec1.into_iter().collect();
        let set2: HashSet<T> = vec2.into_iter().collect();
        // 计算差集：set1中有而set2中没有的元素
        let result: Vec<_> = set1.difference(&set2).cloned().collect();
        result
    }

    /// 计算对称差集：只在其中一个集合中出现的元素
    pub fn symmetric_difference<T>(vec1: Vec<T>, vec2: Vec<T>) -> Vec<T>
    where T: Eq + Hash + Clone {
        let set1: HashSet<T> = vec1.into_iter().collect();
        let set2: HashSet<T> = vec2.into_iter().collect();
        // 计算对称差集：只在其中一个集合中出现的元素
        let result: Vec<_> = set1.symmetric_difference(&set2).cloned().collect();
        result
    }


}


#[cfg(test)]
mod tests {
    use std::collections::HashMap;


    #[test]
    fn test_remove_first() {
        let _map = HashMap::<i32, i32>::new();
    }
}

