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


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

impl<'a> NewStatsCalculator<'a> {
    pub fn from_vec(initial_data: &'a mut Vec<i32>) -> Self {
        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) -> HashMap<&mut i32, i32> {
    //     let mut mode = HashMap::new();
    //     for ref i in self.data {
    //         let count = mode.entry(i).or_insert(0);
    //         *count += 1;
    //     }
    //     mode
    // }
}

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

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

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

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

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

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