extern crate pancurses;

use pancurses::Input::*;
use pancurses::*;

mod board;

use crate::board::*;

struct BoardGui {
    win: Window,
    size: i32,
    cell_height: i32,
    cell_width: i32,
    hoff: i32,
    cur_cell: Position,
}

#[derive(PartialEq)]
enum BGAction {
    Quit,
    None,
}

impl BoardGui {
    fn mv_to_cell(&self, pos: &Position) {
        let y: i32 = pos.y as i32;
        let x: i32 = pos.x as i32;
        if (y < self.size) && (x < self.size) {
            let y = (self.size - y) * self.cell_height + 1;
            let x = self.hoff + x * self.cell_width + 1;
            self.win.mv(y, x);
            self.win.refresh();
        }
    }

    fn draw_grid(&self) {
        for y in 0..self.cell_height * self.size + 1 {
            for x in 0..self.cell_width * self.size + 1 {
                if y % self.cell_height == 0 {
                    if x % self.cell_width == 0 {
                        self.win.mvaddch(y, x + self.hoff, '+');
                    } else {
                        self.win.mvaddch(y, x + self.hoff, '-');
                    }
                } else if x % self.cell_width == 0 {
                    self.win.mvaddch(y, x + self.hoff, '|');
                }
            }
        }
        for y in 0..self.size {
            self.win.mvaddstr(
                y * self.cell_height + self.cell_height / 2,
                0,
                format!("{}.", self.size - y),
            );
        }
        for x in 0..self.size {
            self.win.mvaddstr(
                self.size * self.cell_height + 1,
                self.cell_width * x + self.cell_width / 2 + self.hoff,
                format!("{:x}.", x + 10),
            );
        }
        self.win.refresh();
    }

    fn handle_key(&mut self, key: Input) -> BGAction {
        match key {
            KeyUp => {
                if 0 < self.cur_cell.y {
                    self.cur_cell.y -= 1;
                    self.mv_to_cell(&self.cur_cell);
                }
                BGAction::None
            }
            KeyDown => {
                let y: i32 = self.cur_cell.y as i32;
                if y + 1 < self.size {
                    self.cur_cell.y += 1;
                    self.mv_to_cell(&self.cur_cell);
                }
                BGAction::None
            }
            KeyLeft => {
                if 0 < self.cur_cell.x {
                    self.cur_cell.x -= 1;
                    self.mv_to_cell(&self.cur_cell);
                }
                BGAction::None
            }
            KeyRight => {
                let x: i32 = self.cur_cell.x as i32;
                if x + 1 < self.size {
                    self.cur_cell.x += 1;
                    self.mv_to_cell(&self.cur_cell);
                }
                BGAction::None
            }
            Character('q') => BGAction::Quit,
            x => {
                self.win.addstr(format!("{:?}", x));
                self.win.refresh();
                BGAction::None
            }
        }
    }

    fn init(&self) {
        self.draw_grid();
        self.mv_to_cell(&self.cur_cell);
    }
}

struct MoveEntry {
    win: Window,
}

impl MoveEntry {
    fn init(&self) {
        self.win.attrset(COLOR_PAIR(3) | A_BOLD); // ???? how
        self.win.mvaddstr(0, 0, "Enter move: ashtsaht");
        // self.win.mvchgat(0,12,10,A_NORMAL,COLOR_PAIR(1));
        self.win.refresh();
    }

    fn read_action(&self) -> &str {
        "a1"
    }
}

struct MessageLog {
    win: Window,
}

impl MessageLog {
    fn init(&self) {}

    fn log_error(&self, str: String) {
        // self.win.clear();
        self.win.addstr(str);
        self.win.refresh();
    }
}

fn main() {
    let screen = initscr();
    screen.nodelay(true);
    screen.keypad(true);

    if has_colors() {
        start_color();
    }

    cbreak();
    noecho();

    curs_set(2);

    screen.refresh();

    let bgw = newwin(25, 40, 0, 0);
    let mew = newwin(1, 30, 25, 0);
    let mlw = newwin(3, 70, 26, 0);

    let mut bg = BoardGui {
        win: bgw,
        size: 5,
        cell_height: 4,
        cell_width: 7,
        hoff: 3,
        cur_cell: Position { x: 0, y: 0 },
    };

    let me = MoveEntry { win: mew };

    let ml = MessageLog { win: mlw };

    bg.init();
    me.init();
    ml.init();

    let board_option = Board::new(5, |s| MessageLog::log_error(&ml, s));
    if let Some(mut board) = board_option {
        let pos = Position { x: 0, y: 0 };
        board.perform_action(Action::Place(Player::White, pos, Stone::Flat));
        board.is_legal_action(&Action::Move(Player::White, pos, Direction::Up, vec![0, 1]));
    }

    loop {
        if let Some(inp) = screen.getch() {
            if bg.handle_key(inp) == BGAction::Quit {
                break;
            }
        }
    }
    endwin();
}