use std::{ io, io::Read };

mod minesweeper {
    use std::convert::TryFrom;
    use std::fmt::Display;
    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: &[(i8,i8)] = &[
            (-1,-1),(0,-1),(1,-1),
            (-1, 0),       (1, 0),
            (-1, 1),(0, 1),(1, 1),
        ];
    #[derive(PartialEq)]
    pub enum Phase {
        SafeFirstMove,
        Run,
        Die,
        Win,
        Leave,
    }
    pub struct Game {
        pub phase: Phase,
        pub board: Board,
        pub mine_count: usize,
    }
    impl Display for Game {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            writeln!(f, "{}", self.board)
        }
    }

    pub struct Board {
        pub data: Vec<u8>,
        pub width: usize,
        pub height: usize,
        pub hidden_tiles: usize,
    }
    pub enum MoveType {
        Reveal,
        ToggleFlag,
    }
    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 kaboom = match m.t {
                MoveType::Reveal => {
                    if self.phase == Phase::SafeFirstMove {
                        self.phase = Phase::Run;
                    }
                    let kaboom: bool;
                    self.board = {
                        let mr = self.board.reveal(m.pos);
                        kaboom = mr.1;
                        mr.0
                    };
                    kaboom
                },
                MoveType::ToggleFlag => {
                    let kaboom: bool;
                    self.board = {
                        let mr = self.board.flag(m.pos);
                        kaboom = mr.1;
                        mr.0
                    };
                    kaboom
                },
            };
            if kaboom {
                self.phase = match self.phase {
                    Phase::SafeFirstMove => unimplemented!(),
                    Phase::Run => Phase::Die,
                    _ => unreachable!(),
                }
            }
            if self.board.hidden_tiles == self.mine_count {
                self.phase = Phase::Win;
            }
            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(x as i8 + nx);
                        let nyc = usize::try_from(y as i8 + 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(pos.0 as i8 + ox);
                    let nyr = usize::try_from(pos.1 as i8 + 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) };
                            let off = self.pos_to_off((nx,ny));
                            let c = &mut self.data[off];
                            if *c == HIDDEN_BIT {
                                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 }
        }
    }

    impl Display for Board {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            for y in 0..self.height {
                for x in 0..self.width {
                    let c = &self.data[self.pos_to_off((x,y))];
                    match *c {
                        0 => write!(f, " ")?,
                        _ if *c <= 8 => write!(f, "{}", c.to_string())?,
                        _ if (*c & FLAGGED_BIT) > 0 => write!(f, "F")?,
                        _ if (*c & HIDDEN_BIT) > 0 => write!(f, "-")?,
                        _ if (*c & CORRECT_BIT) > 0 => write!(f, "C")?,
                        _ if *c == MINE_VAL => write!(f, "O")?,
                        _ => write!(f, "?")?,
                    }
                }
                writeln!(f, "\r")?;
            }
            Ok(())
        }
    }
}

use minesweeper::*;
use std::convert::{ TryFrom, TryInto };

fn main() -> Result<(), io::Error> {
    let board = Board::new(10,10);
    let mut game = Game::new(board, 10);
    let mut cursor: (usize, usize) = (5,5);
    while game.phase == Phase::Run || game.phase == Phase::SafeFirstMove {
        println!("{}",game);
        let mm = playerctrl(
            (cursor.0.try_into().unwrap(), cursor.1.try_into().unwrap()),
            (game.board.width.try_into().unwrap(), game.board.height.try_into().unwrap()))?;
        match mm {
            MetaMove::Move(m) => game = game.act(m),
            MetaMove::CursorMove(newc) => cursor = newc,
            MetaMove::Quit => game.phase = Phase::Leave,
            MetaMove::Noop => (),
        }
    }

    print!("{}", game);
    Ok(())
}

enum MetaMove {
    Move(Move),
    CursorMove((usize, usize)),
    Noop,
    Quit,
}
fn playerctrl(mut cursor: (isize, isize), bounds: (isize, isize)) -> io::Result<MetaMove> {
    let stdin = io::stdin();
    let lstdin = stdin.lock();
    let mut input = lstdin.bytes();
    Ok(match input.next().expect("bad/no input byte")? {
        b'w' => { cursor.1 -= 1; MetaMove::CursorMove(cursor_bounds(cursor, bounds)) },
        b's' => { cursor.1 += 1; MetaMove::CursorMove(cursor_bounds(cursor, bounds)) },
        b'a' => { cursor.0 -= 1; MetaMove::CursorMove(cursor_bounds(cursor, bounds)) },
        b'd' => { cursor.0 += 1; MetaMove::CursorMove(cursor_bounds(cursor, bounds)) },
        b'r' => MetaMove::Move(Move { t: MoveType::Reveal, pos: cursor_bounds(cursor, bounds) }),
        b'f' => MetaMove::Move(Move { t: MoveType::ToggleFlag, pos: cursor_bounds(cursor, bounds) }),
        b'q' => MetaMove::Quit,
        v => { println!("{:?}", v); MetaMove::Noop },
    })
}
fn cursor_bounds(mut c: (isize, isize), b: (isize, isize)) -> (usize, usize) {
    if c.0 > b.0 - 1 {
        c.0 = 0;
    }
    else if c.0 < 0 {
        c.0 = b.0 - 1;
    }
    if c.1 > b.1 - 1 {
        c.1 = 0;
    }
    else if c.1 < 0 {
        c.1 = b.1 - 1;
    }
    (
        usize::try_from(c.0).unwrap(),
        usize::try_from(c.1).unwrap()
    )
}