use crate::*;
use std::time::Duration;
use std::thread::{spawn, JoinHandle};
use crossterm::event::{Event, poll, read};

#[derive(Debug, Clone)]
pub struct TuiIn {
    /// Exit flag
    pub exited: Arc<AtomicBool>,
    /// Input event
    pub event: TuiEvent,
}
impl Input for TuiIn {
    type Event   = TuiEvent;
    type Handled = bool;
    fn event   (&self) -> &TuiEvent { &self.event }
    fn is_done (&self) -> bool { self.exited.fetch_and(true, Relaxed) }
    fn done    (&self) { self.exited.store(true, Relaxed); }
}
impl TuiIn {
    /// Spawn the input thread.
    pub fn run_input <T: Handle<TuiIn> + Send + Sync + 'static> (
        engine: &Arc<RwLock<Tui>>,
        state:  &Arc<RwLock<T>>,
        timer:  Duration
    ) -> JoinHandle<()> {
        let exited = engine.read().unwrap().exited.clone();
        let state  = state.clone();
        spawn(move || loop {
            if exited.fetch_and(true, Relaxed) {
                break
            }
            if poll(timer).is_ok() {
                let event = read().unwrap();
                match event {
                    Event::Key(KeyEvent {
                        code:      KeyCode::Char('c'),
                        modifiers: KeyModifiers::CONTROL,
                        kind:      KeyEventKind::Press,
                        state:     KeyEventState::NONE
                    }) => {
                        exited.store(true, Relaxed);
                    },
                    _ => {
                        let exited = exited.clone();
                        let event  = TuiEvent::from_crossterm(event);
                        if let Err(e) = state.write().unwrap().handle(&TuiIn { exited, event }) {
                            panic!("{e}")
                        }
                    }
                }
            }
        })
    }
}