use std::error::Error;
use std::fmt;

fn main() {
    let grid = Grid::new(10);
    println!("{:?}", grid);
}
type Point = (usize, usize);

#[derive(Debug)]
pub struct Grid {
    pub state: Vec<Vec<bool>>,
    pub size: usize,
}

impl Grid {
    pub fn new(size: usize) -> Self {
        let mut state = Vec::new();
        for _ in 0..size {
            let mut temp = vec![];
            for _ in 0..size {
                temp.push(false);
            }
            state.push(temp);
        }
        Self { state, size }
    }
    pub fn is_cell_living(&self, cell: Point) -> Option<bool> {
        if let Some(status) = self.state.get(cell.1)?.get(cell.0) {
            Some(*status)
        } else {
            None
        }
    }
    pub fn set_cell_living(&mut self, cell: Point) -> Option<()> {
        *self.state.get_mut(cell.1)?.get_mut(cell.0)? = true;
        Some(())
    }
    pub fn set_cell_dead(&mut self, cell: Point) -> Option<()> {
        *self.state.get_mut(cell.1)?.get_mut(cell.0)? = false;
        Some(())
    }
    pub fn toggle_cell(&mut self, cell: Point) -> Option<()> {
        *self.state.get_mut(cell.1)?.get_mut(cell.0)? = !*self.state.get(cell.1)?.get(cell.0)?;
        Some(())
    }
    pub fn evaluate_cell(&mut self, cell: Point) -> Option<()> {
        let count = self.count_neighbors(cell)?;
        let status = self.is_cell_living(cell)?;
        match (count, status) {
            (0..=1, true) => self.toggle_cell(cell),
            (2..=3, true) => self.toggle_cell(cell),
            (_, true) => self.toggle_cell(cell),
            (3, false) => self.toggle_cell(cell),
            _ => None,
        };
        Some(())
    }
    pub fn count_neighbors(&self, cell: Point) -> Option<usize> {
        let mut sum: usize = 0;
        for x in (cell.0 - 1)..=(cell.0 + 1) {
            for y in (cell.1 - 1)..=(cell.1 + 1) {
                if (x, y) != cell {
                    if let Some(status) = self.is_cell_living((x, y)) {
                        if status { sum += 1; }
                    };
                }
            }
        }
        Some(sum)
    }
    fn check_valid_coords(&self, cell: Point) -> bool {
        if let Some(vec) = self.state.get(cell.0) {
            if let Some(_) = vec.get(cell.1) {
                true
            } else {
                false
            }
        } else {
            false
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_build_empty() {
        let grid = Grid::new(10);
        let empty: bool = grid.state.iter().all(|v| v.iter().all(|c| *c == false));
        assert!(empty);
    }
    #[test]
    fn test_toggle() {
        let mut grid = Grid::new(10);
        let origin = (0, 0);
        assert!(!grid.is_cell_living(origin).unwrap());
        grid.toggle_cell(origin).unwrap();
        assert!(grid.is_cell_living(origin).unwrap());
    }
    #[test]
    fn test_set_living_slash_dead() {
        let mut grid = Grid::new(10);
        let point = (5, 5);
        grid.set_cell_living(point).unwrap();
        assert!(grid.is_cell_living(point).unwrap());
        grid.set_cell_dead(point).unwrap();
        assert!(!grid.is_cell_living(point).unwrap());
    }
    #[test]
    fn test_count_neighbors() {
        let mut grid = Grid::new(5);
        grid.set_cell_living((3, 3)).unwrap();
        grid.set_cell_living((3, 4)).unwrap();
        grid.set_cell_living((3, 2)).unwrap();
        assert_eq!(grid.count_neighbors((4, 3)).unwrap(), 3);
    }
    #[test]
    fn test_evaluate_cell() {
        let mut grid = Grid::new(10);
        grid.set_cell_living((1,2)).unwrap();
        grid.set_cell_living((0,2)).unwrap();
        grid.set_cell_living((0,3)).unwrap();
        grid.evaluate_cell((1,2)).unwrap();
        assert!(grid.is_cell_living((1,2)).unwrap());
        grid.evaluate_cell((1,3)).unwrap();
        assert!(grid.is_cell_living((1,3)).unwrap());
        grid.evaluate_cell((5,5)).unwrap();
        assert!(!grid.is_cell_living((5,5)).unwrap());
    }
}