use fltk::{app::*, button::*, draw::*, frame::*, menu::*, text::*, window::*};

#[derive(Clone, Copy)]
enum GUIMessage {
    None,
    Test,
}

struct GUIBoard {
    frame: Frame,
    test: bool,
}

impl GUIBoard {
    fn new(frame: Frame) -> GUIBoard {
        let mut g = GUIBoard { frame, test: false };
        g.frame.draw2(g.draw());
        g
    }

    fn change(&mut self) {
        self.test = !self.test;

        self.frame.draw2(self.draw());
        self.frame.set_damage(true);
    }

    fn draw(&self) -> impl Fn(&mut Frame) {
        let tc = self.test;
        move |frame: &mut Frame| {
            const BOARD_PAD_INNER: i32 = 5;
            let bx = frame.x() + BOARD_PAD_INNER;
            let by = frame.y() + BOARD_PAD_INNER;
            push_clip(frame.x(), frame.y(), frame.width(), frame.height());
            set_draw_color(if tc { Color::Blue } else { Color::Red });
            draw_rectf(bx, by, 100, 30);
            pop_clip();
        }
    }
}

pub struct GUI {
    app: App,
    window: Window,
    board: GUIBoard,
    log: TextDisplay,
    sender: Sender<GUIMessage>,
    receiver: Receiver<GUIMessage>,
}

impl GUI {
    pub fn new() -> GUI {
        let app = App::default();

        // TODO: Why is this not the same as
        /*
               let mut window = Window::default()
                   .with_size(800, 600)
                   .with_label("Takwrap")
                   .center_screen();
        */
        // Windows made that way are not resizable?

        let mut window = Window::new(0, 0, 800, 600, "Takwrap").center_screen();

        let (sender, receiver) = channel::<GUIMessage>();

        let mut menu = SysMenuBar::default().with_size(800, 24);
        // menu.set_text_font(Font::Helvetica);
        menu.set_color(Color::Light2);
        menu.add_emit(
            "&File/New...\t",
            Shortcut::None,
            MenuFlag::Normal,
            sender,
            GUIMessage::None,
        );
        menu.add_emit(
            "&File/Open...\t",
            Shortcut::None,
            MenuFlag::Normal,
            sender,
            GUIMessage::Test,
        );

        const LOG_WIDTH: i32 = 10 * 16;
        const LOG_PAD: i32 = 0;
        let mut log = TextDisplay::default()
            .with_size(LOG_WIDTH, 600 - 2 * LOG_PAD - menu.height())
            .with_pos(800 - LOG_WIDTH - LOG_PAD, menu.height());
        log.set_buffer(Some(TextBuffer::default()));
        log.insert("test");

        const BOARD_PAD: i32 = 0;
        let mut board_frame = Frame::default()
            .with_size(
                800 - LOG_WIDTH - LOG_PAD * 2 - BOARD_PAD,
                600 - 2 * BOARD_PAD - menu.height(),
            )
            .below_of(&menu, BOARD_PAD);
        board_frame.set_frame(FrameType::EmbossedBox);

        window.resizable(&mut board_frame);
        window.end();
        window.show();

        let board = GUIBoard::new(board_frame);

        // button.emit(sender, GUIMessage::Foo);

        GUI {
            app,
            board,
            window,
            log,
            sender,
            receiver,
        }
    }

    pub fn run(&mut self) -> Result<(), fltk::prelude::FltkError> {
        // self.window.show();

        while self.app.wait() {
            if let Some(msg) = self.receiver.recv() {
                match msg {
                    GUIMessage::Test => {
                        self.board.change();
                    }
                    _ => (),
                }
            }
        }
        Ok(())
    }
}