use std::convert::TryFrom;
use rand::{ thread_rng, Rng, distributions::Uniform };
const HIDDEN_BIT: u8 = 1 << 7;
pub const FLAGGED_BIT: u8 = 1 << 6;
const CORRECT_BIT: u8 = 1 << 5; // grading for a rightly flagged mine
const MINE_VAL: u8 = !(HIDDEN_BIT | FLAGGED_BIT | CORRECT_BIT);
const NEIGH_OFFS: &[(isize,isize)] = &[
    (-1,-1),(0,-1),(1,-1),
    (-1, 0),       (1, 0),
    (-1, 1),(0, 1),(1, 1),
];
#[derive(PartialEq)]
pub enum Phase {
    SafeFirstMove,
    FirstMoveFail,
    Run,
    Die,
    Win,
    Leave,
}
pub struct Game {
    pub phase: Phase,
    pub board: Board,
    pub mine_count: usize,
}
pub struct Board {
    pub data: Vec<u8>,
    pub width: usize,
    pub height: usize,
    pub hidden_tiles: usize,
}
#[derive(Debug)]
pub enum MoveType {
    Reveal,
    ToggleFlag,
}
#[derive(Debug)]
pub struct Move {
    pub t: MoveType,
    pub pos: (usize,usize),
}
pub struct MoveResult(pub Board, pub bool);
impl Game {
    pub fn new(board: Board, mine_count: usize) -> Self {
        let mut g = Game { phase: Phase::SafeFirstMove, board, mine_count };
        g.board = g.board.spread_mines(mine_count);
        g
    }
    pub fn act(mut self, m: Move) -> Self {
        let lost_phase = | phase | {
            match phase {
                Phase::SafeFirstMove => Phase::FirstMoveFail,
                Phase::Run => Phase::Die,
                _ => unreachable!(),
            }
        };

        match m.t {
            MoveType::Reveal => {
                let kaboom: bool;
                self.board = {
                    let mr = self.board.reveal(m.pos);
                    kaboom = mr.1;
                    mr.0
                };
                if kaboom { self.phase = lost_phase(self.phase) }
                if self.phase == Phase::SafeFirstMove { self.phase = Phase::Run }
            },
            MoveType::ToggleFlag => self.board = self.board.flag(m.pos).0,
        };

        if self.board.hidden_tiles == self.mine_count {
            self.phase = Phase::Win;
        }
        if self.phase == Phase::FirstMoveFail {
            self.board = Board::new(self.board.width, self.board.height);
            self.mine_count -= 1;
            self.board = self.board.spread_mines(self.mine_count);
            self.phase = Phase::SafeFirstMove;
            self = self.act(m);
        }
        self
    }
}
impl Board {
    pub fn new(w: usize, h: usize) -> Self {
        Board {
            data: [HIDDEN_BIT].repeat(w*h),
            width: w,
            height: h,
            hidden_tiles: w*h,
        }
    }
    pub fn spread_mines(mut self, count: usize) -> Self {
        let mut rng = thread_rng();
        let mut c = count;
        let w = self.width;
        let h = self.height;
        while c > 0 {
            let randpos: (usize, usize) = (rng.sample(Uniform::new(0,w-1)), rng.sample(Uniform::new(0,h-1)));
            let o = self.pos_to_off(randpos);
            if self.data[o] == MINE_VAL | HIDDEN_BIT { continue }
            else {
                self.data[o] |= MINE_VAL;
                c -= 1;
                for (nx,ny) in NEIGH_OFFS {
                    let x = randpos.0;
                    let y = randpos.1;
                    let nxc = usize::try_from(isize::try_from(x).unwrap() + nx);
                    let nyc = usize::try_from(isize::try_from(y).unwrap() + ny);
                    let _ = nxc.and_then(|nx: usize| { nyc.and_then(|ny: usize| {
                        if nx > w - 1 || ny > h - 1 { return usize::try_from(-1) };
                        let off = self.pos_to_off((nx,ny));
                        let c = &mut self.data[off];
                        if *c != HIDDEN_BIT | MINE_VAL {
                            *c += 1;
                        }
                        Ok(0)
                    })
                    });
                }
            }
        }
        self
    }
    pub fn pos_to_off(&self, pos: (usize, usize)) -> usize {
        pos.0 + pos.1 * self.width
    }
    pub fn flood_reveal(&mut self, pos: (usize, usize)) {
        if pos.0 > self.width || pos.1 > self.height { return; }
        let off = self.pos_to_off(pos);
        let c = &mut self.data[off];
        if *c & HIDDEN_BIT > 0 {
            *c &= !(HIDDEN_BIT | FLAGGED_BIT);
            self.hidden_tiles -= 1;
            if *c > 0 { return }
            drop(c);
            for (ox,oy) in NEIGH_OFFS {
                let nxr = usize::try_from(isize::try_from(pos.0).unwrap() + ox);
                let nyr = usize::try_from(isize::try_from(pos.1).unwrap() + oy);
                let _ = nxr.and_then(|nx: usize| { nyr.and_then(|ny: usize| {
                    if nx > self.width - 1 || ny > self.height - 1 { return usize::try_from(-1) };
                    self.flood_reveal((nx, ny));
                    Ok(0)
                })
                });
            }
        }
    }
    pub fn reveal(mut self, pos: (usize, usize)) -> MoveResult {
        if pos.0 > self.width - 1 || pos.1 > self.height - 1 { panic!("OOB reveal"); }
        let off = self.pos_to_off(pos);
        self.flood_reveal(pos);
        let c = self.data[off];
        MoveResult { 0: self, 1: (c & !(FLAGGED_BIT | CORRECT_BIT)) == MINE_VAL } // Kaboom
    }
    pub fn grade(mut self) -> Board {
        for i in &mut self.data {
            if *i == MINE_VAL | FLAGGED_BIT | HIDDEN_BIT {
                *i |= CORRECT_BIT;
            }
        }
        self
    }
    pub fn flag(mut self, pos: (usize, usize)) -> MoveResult {
        let off = self.pos_to_off(pos);
        self.data[off] ^= FLAGGED_BIT;
        MoveResult { 0: self, 1: false }
    }

    pub fn render(&self, cursor: Option<(usize,usize)>) -> Vec<u8> {
        const CYAN: &[u8] = &[27,b'[',b'3',b'6',b'm'];
        const YELLOW: &[u8] = &[27,b'[',b'3',b'3',b'm'];
        const GREEN: &[u8] = &[27,b'[',b'3',b'2',b'm'];
        const RED: &[u8] = &[27,b'[',b'3',b'1',b'm'];
        const FG: &[u8] = &[27,b'[',b'3',b'9',b'm'];
        const ULINE: &[u8] = &[27,b'[',b'4',b'm'];
        const REGULAR: &[u8] = &[27,b'[',b'0',b'm'];

        let mut ret = vec![27];
        let mut cur_clr = FG;
        for y in 0..self.height {
            ret.extend_from_slice(b"<br>");
            for x in 0..self.width {
                let c = &self.data[self.pos_to_off((x,y))];
                let is_cursor = if let Some(cursor) = cursor { cursor.0 == x && cursor.1 == y } else { false };
                if is_cursor { ret.extend_from_slice(ULINE); }
                match *c {
                    0 => ret.push(b' '),
                    _ if *c <= 8 => { if cur_clr != FG { ret.extend_from_slice(FG); cur_clr = FG; } ret.push(b'0' + c); },
                    _ if (*c & CORRECT_BIT) > 0 => { if cur_clr != GREEN { ret.extend_from_slice(GREEN); cur_clr = GREEN; } ret.push(b'F') },
                    _ if (*c & FLAGGED_BIT) > 0 => { if cur_clr != YELLOW { ret.extend_from_slice(YELLOW); cur_clr = YELLOW; } ret.push(b'F'); },
                    _ if (*c & HIDDEN_BIT) > 0 => { if cur_clr != CYAN { ret.extend_from_slice(CYAN); cur_clr = CYAN; } ret.push(35); },
                    _ if *c == MINE_VAL => { if cur_clr != RED { ret.extend_from_slice(RED); cur_clr = RED; } ret.push(b'O'); },
                    _ => ret.push(b'?'),
                }
                if is_cursor { ret.extend_from_slice(REGULAR); ret.extend_from_slice(cur_clr); }
            }
        }
        ret
    }
}