use ::std::collections::HashMap;
use std::convert::TryFrom;

#[derive(Debug)]
pub struct NewStatsCalculator {
    data: Vec<i32>,
    length: u32,
    total: i32,
}

impl NewStatsCalculator {
    pub fn from_vec(initial_data: &[i32]) -> Self {
        let initial_data = initial_data.to_vec();
        let mut instance = NewStatsCalculator {
            data: initial_data,
            length: 0,
            total: 0,
        };
        instance.get_length();
        instance.get_total();
        instance
    }

    // pub fn initialise(&mut self) -> () {
    //     self.total = self.data.iter().sum();
    //     let length = i32::try_from(self.data.len());
    //     // self.length = match length {
    //     //     Ok(i) => i,
    //     //     _ => 0,
    //     // };
    //     if let Ok(i) = length {
    //         self.length = i;
    //     } else {
    //         self.length = 0;
    //     }
    // }

    fn get_length(&mut self) {
        let length = u32::try_from(self.data.len());

        if let Ok(i) = length {
            self.length = i;
        } else {
            self.length = 0;
        }
    }

    fn get_total(&mut self) {
        self.total = self.data.iter().sum();
    }

    pub fn get_mean(&self) -> f32 {
        self.total as f32 / self.length as f32
    }

    pub fn get_median(&mut self) -> f32 {
        let mid = self.length as usize / 2;

        self.data.sort_unstable();

        if self.length % 2 == 0 {
            (self.data[mid - 1] as f32 + self.data[mid] as f32) / 2.0
        } else {
            self.data[mid] as f32
        }
    }

    pub fn get_mode(&self) -> Option<(i32, i32)> {
        let mut mode: HashMap<i32, i32> = HashMap::new();
        for i in &self.data {
            let count = mode.entry(*i).or_insert(0);
            *count += 1;
        }
        let mut mode_value: Option<(i32, i32)> = mode
            .iter()
            .max_by(|a, b| a.1.cmp(b.1))
            .map(|(k, v)| (*k, *v));

        if let Some((_, v)) = mode_value {
            if v == 1 {
                mode_value = None
            }
        }

        // println!("{:?}", mode_value);
        mode_value
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_get_length() {
        let data = vec![1, 2, 3, 4, 5, 6];
        let mut test = NewStatsCalculator::from_vec(&data);
        test.get_length();
        assert_eq!(test.length, 6);
    }

    #[test]
    fn test_get_total() {
        let data = vec![1, 2, 3, 4, 5, 6];
        let mut test = NewStatsCalculator::from_vec(&data);
        test.get_length();
        assert_eq!(test.total, 21);
    }

    #[test]
    fn test_get_mean() {
        let data = vec![1, 2, 3, 4, 5, 6];
        let test = NewStatsCalculator::from_vec(&data);
        assert_eq!(test.get_mean(), 3.5);
    }

    #[test]
    fn test_get_median_even() {
        let data = vec![1, 2, 3, 4, 5, 6];
        let mut test = NewStatsCalculator::from_vec(&data);
        assert_eq!(test.get_median(), 3.5);
    }

    #[test]
    fn test_get_median_odd() {
        let data = vec![1, 2, 3, 4, 5, 6, 7];
        let mut test = NewStatsCalculator::from_vec(&data);
        assert_eq!(test.get_median(), 4.0);
    }

    #[test]
    fn test_get_mode_with_mode() {
        let data = vec![1, 2, 3, 4, 5, 6, 6];
        let test = NewStatsCalculator::from_vec(&data);
        assert_eq!(test.get_mode(), Some((6, 2)))
    }

    #[test]
    fn test_get_mode_without_mode() {
        let data = vec![1, 2, 3, 4, 5, 6];
        let test = NewStatsCalculator::from_vec(&data);
        assert_eq!(test.get_mode(), None)
    }
}