use crate::{*, tui::*};
pub use crossterm::event::Event;

#[derive(Debug, Clone)]
pub struct TuiIn {
    pub(crate) exited: Arc<AtomicBool>,
    pub(crate) event:  Event,
}

impl Input<Tui> for TuiIn {
    type Event = Event;
    fn event (&self) -> &Event {
        &self.event
    }
    fn is_done (&self) -> bool {
        self.exited.fetch_and(true, Relaxed)
    }
    fn done (&self) {
        self.exited.store(true, Relaxed);
    }
}

/// Define a key
pub const fn key (code: KeyCode) -> Event {
    let modifiers = KeyModifiers::NONE;
    let kind      = KeyEventKind::Press;
    let state     = KeyEventState::NONE;
    Event::Key(KeyEvent { code, modifiers, kind, state })
}

/// Add Ctrl modifier to key
pub const fn ctrl (event: Event) -> Event {
    match event {
        Event::Key(mut event) => {
            event.modifiers = event.modifiers.union(KeyModifiers::CONTROL)
        },
        _ => {}
    }
    event
}

/// Add Alt modifier to key
pub const fn alt (event: Event) -> Event {
    match event {
        Event::Key(mut event) => {
            event.modifiers = event.modifiers.union(KeyModifiers::ALT)
        },
        _ => {}
    }
    event
}

/// Add Shift modifier to key
pub const fn shift (event: Event) -> Event {
    match event {
        Event::Key(mut event) => {
            event.modifiers = event.modifiers.union(KeyModifiers::SHIFT)
        },
        _ => {}
    }
    event
}

#[macro_export] macro_rules! key_pat {
    (Ctrl-Alt-$code:pat) => { key_event_pat!($code, KeyModifiers::CONTROL | KeyModifiers::ALT) };
    (Ctrl-$code:pat)     => { key_event_pat!($code, KeyModifiers::CONTROL) };
    (Alt-$code:pat)      => { key_event_pat!($code, KeyModifiers::ALT) };
    (Shift-$code:pat)    => { key_event_pat!($code, KeyModifiers::SHIFT) };
    ($code:pat)          => { crossterm::event::Event::Key(KeyEvent {
        code:      $code,
        modifiers: KeyModifiers::NONE,
        kind:      KeyEventKind::Press,
        state:     KeyEventState::NONE
    }) };
}

#[macro_export] macro_rules! key_event_pat {
    ($code:pat) => {
        crossterm::event::Event::Key(KeyEvent {
            code:      $code,
            modifiers: KeyModifiers::NONE,
            kind:      KeyEventKind::Press,
            state:     KeyEventState::NONE
        })
    };
    ($code:pat, $modifiers: pat) => {
        crossterm::event::Event::Key(KeyEvent {
            code:      $code,
            modifiers: $modifiers,
            kind:      KeyEventKind::Press,
            state:     KeyEventState::NONE
        })
    };
}

#[macro_export] macro_rules! kexp {
    (Ctrl-Alt-$code:ident) => { key_event_expr!($code, KeyModifiers::from_bits(0b0000_0110).unwrap()) };
    (Ctrl-$code:ident)     => { key_event_expr!($code, KeyModifiers::CONTROL) };
    (Alt-$code:ident)      => { key_event_expr!($code, KeyModifiers::ALT) };
    (Shift-$code:ident)    => { key_event_expr!($code, KeyModifiers::SHIFT) };
    ($code:ident)          => { key_event_expr!($code) };
    ($code:expr)           => { key_event_expr!($code) };
}

#[macro_export] macro_rules! key_expr {
    (Ctrl-Alt-$code:ident) => { key_event_expr!($code, KeyModifiers::CONTROL | KeyModifiers::ALT) };
    (Ctrl-$code:ident)     => { key_event_expr!($code, KeyModifiers::CONTROL) };
    (Alt-$code:ident)      => { key_event_expr!($code, KeyModifiers::ALT) };
    (Shift-$code:ident)    => { key_event_expr!($code, KeyModifiers::SHIFT) };
    ($code:ident)          => { key_event_expr!($code) };
}

#[macro_export] macro_rules! key_event_expr {
    ($code:expr, $modifiers: expr) => {
        crossterm::event::Event::Key(KeyEvent {
            code:      $code,
            modifiers: $modifiers,
            kind:      KeyEventKind::Press,
            state:     KeyEventState::NONE
        })
    };
    ($code:expr) => {
        crossterm::event::Event::Key(KeyEvent {
            code:      $code,
            modifiers: KeyModifiers::NONE,
            kind:      KeyEventKind::Press,
            state:     KeyEventState::NONE
        })
    };
}