use crate::Point;

pub struct Screen {
    pub center: Point,
    max_x: i32,
    max_y: i32,
}

use ncurses::*;

impl Screen {
    pub fn new(max_x: i32, max_y: i32) -> Screen {
        Screen {
            center: Point(max_x / 2, max_y / 2),
            max_x,
            max_y,
        }
    }

    pub fn is_in_bounds(&self, pos: &Point) -> bool {
        (pos.0 > -self.max_x && pos.0 < self.max_x) && (pos.1 > -self.max_y && pos.1 < self.max_y)
    }

    pub fn get_valid_movements(&self, pos: &Point) -> Vec<Point> {
        let binding = pos.get_neighbors();
        binding
            .iter()
            .filter(|e| self.is_in_bounds(e))
            .map(|e| e.clone())
            .collect()
    }

    pub fn render(&self, p: &Point, char: &str) {
        mvprintw(p.1 + self.center.1, p.0 + self.center.0, char);
    }
}

#[test]
fn test_in_bounds() {
    let x = 20;
    let y = 20;
    let s = Screen::new(x, y);

    assert!(&s.is_in_bounds(&Point(0, 0)));
    assert!(!&s.is_in_bounds(&Point(21, 0)));
}

#[test]
fn test_get_valid_movements_board() {
    let x = 20;
    let y = 20;
    let s = Screen::new(x, y);

    let valid = s.get_valid_movements(&Point(0,0));
    assert_eq!(valid, Point(0,0).get_neighbors());

    let border = s.get_valid_movements(&Point(19,19));
    assert!(border.len() == 2);
}

pub enum BoardCommand {
    Dig(Point),
    LayEgg(Point, u32),
    Hatch(u32, u32),
    Noop,
}