use std::{io, time::Duration};

use crossterm::{
    cursor::position,
    event::{DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
    execute,
    terminal::{disable_raw_mode, enable_raw_mode},
};
use mio::unix::SourceFd;
use mio::{Events, Interest, Poll, Token};

const HELP: &str = r#"Blocking poll() & non-blocking read()
 - Keyboard, mouse and terminal resize events enabled
 - Hit "c" to print current cursor position
 - Use Esc to quit
"#;

fn print_events() -> anyhow::Result<()> {
    let mut events = Events::with_capacity(1);
    let mut mio_poll = Poll::new()?;

    // Register a READABLE interest on standard input
    mio_poll.registry()
        .register(&mut SourceFd(&0), Token(0), Interest::READABLE)?;

    loop {
        // Check if we have a buffered event ready?
        if !crossterm::event::poll(Duration::ZERO)? {
            // We don't have an event ready, so start polling stdin ourselves
            events.clear();
            match mio_poll.poll(&mut events, None) {
                Ok(_) => {
                    // an event might be ready on stdin
                }
                Err(err) if err.kind() == io::ErrorKind::Interrupted => {
                    // we got signaled, let's handle it here
                    println!("Signal received !\r");
                    // then we go back to polling
                    continue;
                }
                Err(err) => {
                    // we got an `mio` error
                    return Err(err.into());
                }
            }
        }

        // It's guaranteed that read() won't block if `poll` returns `Ok(true)`
        let event = crossterm::event::read()?;

        println!("Event::{:?}\r", event);

        if event == Event::Key(KeyCode::Char('c').into()) {
            println!("Cursor position: {:?}\r", position());
        }

        if event == Event::Key(KeyCode::Esc.into()) {
            break;
        }
    }

    Ok(())
}

fn main() -> anyhow::Result<()> {
    println!("{}", HELP);

    enable_raw_mode()?;

    let mut stdout = io::stdout();
    execute!(stdout, EnableMouseCapture)?;

    if let Err(e) = print_events() {
        println!("Error: {:?}\r", e);
    }

    execute!(stdout, DisableMouseCapture)?;

    disable_raw_mode()?;
    Ok(())
}