skim 5.4.0

use std::future::Future;
use std::pin::Pin;
use std::sync::{Arc, Mutex};

use crossterm::event::{KeyEvent, MouseEvent};
use derive_more::{Debug, Eq, PartialEq};

type BoxError = Box<dyn std::error::Error + Sync + Send>;
type BoxFuture<'a> = Pin<Box<dyn Future<Output = Result<Vec<Event>, BoxError>> + Send + 'a>>;

/// Trait object stored inside [`ActionCallback`].
///
/// Having an explicit trait (rather than a bare `dyn Fn` type alias) allows
/// Rust to correctly resolve the higher-ranked lifetime in the return type.
trait AsyncCallbackFn: Send {
    fn call<'a>(&'a self, app: &'a mut crate::tui::App) -> BoxFuture<'a>;
}

/// Adapter that stores a concrete async closure and implements [`AsyncCallbackFn`].
struct AsyncFnWrapper<F>(F);

impl<F, Fut> AsyncCallbackFn for AsyncFnWrapper<F>
where
    F: for<'a> Fn(&'a mut crate::tui::App) -> Fut + Send,
    Fut: Future<Output = Result<Vec<Event>, BoxError>> + Send + 'static,
{
    fn call<'a>(&'a self, app: &'a mut crate::tui::App) -> BoxFuture<'a> {
        Box::pin((self.0)(app))
    }
}

/// Adapter that stores a plain synchronous closure and implements [`AsyncCallbackFn`].
struct SyncFnWrapper<F>(F);

impl<F> AsyncCallbackFn for SyncFnWrapper<F>
where
    F: Fn(&mut crate::tui::App) -> Result<Vec<Event>, BoxError> + Send,
{
    fn call<'a>(&'a self, app: &'a mut crate::tui::App) -> BoxFuture<'a> {
        Box::pin(std::future::ready((self.0)(app)))
    }
}

/// A custom action callback that receives a mutable reference to the App.
///
/// The closure will be called with a mutable reference to App and should return
/// a vec of events that will be processed after the callback completes.
///
/// Both sync and async closures are supported:
/// - Use [`ActionCallback::new`] to wrap an **async** closure or block.
/// - Use [`ActionCallback::new_sync`] to wrap a plain synchronous closure.
#[derive(Clone)]
pub struct ActionCallback(Arc<Mutex<dyn AsyncCallbackFn>>);

impl std::fmt::Debug for ActionCallback {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ActionCallback").finish()
    }
}

impl ActionCallback {
    /// Create a new action callback from an **async** closure or block.
    ///
    /// ```rust,ignore
    /// ActionCallback::new(|app| async move {
    ///     // async work here …
    ///     Ok(vec![])
    /// });
    /// ```
    pub fn new<F, Fut>(f: F) -> Self
    where
        F: for<'a> Fn(&'a mut crate::tui::App) -> Fut + Send + 'static,
        Fut: Future<Output = Result<Vec<Event>, BoxError>> + Send + 'static,
    {
        Self(Arc::new(Mutex::new(AsyncFnWrapper(f))))
    }

    /// Create a new action callback from a plain **synchronous** closure.
    ///
    /// This is a convenience wrapper; the closure is lifted into an immediately-
    /// resolving future so it integrates with the same async call site.
    ///
    /// ```rust,ignore
    /// ActionCallback::new_sync(|app| {
    ///     Ok(vec![Event::Action(Action::SelectAll)])
    /// });
    /// ```
    pub fn new_sync<F>(f: F) -> Self
    where
        F: Fn(&mut crate::tui::App) -> Result<Vec<Event>, BoxError> + Send + 'static,
    {
        Self(Arc::new(Mutex::new(SyncFnWrapper(f))))
    }

    /// Call the callback with an App reference, driving the returned future to completion.
    ///
    /// Must be called from within a Tokio multi-thread runtime context.
    pub(crate) fn call(&self, app: &mut crate::tui::App) -> Result<Vec<Event>, BoxError> {
        let callback = self.0.lock().unwrap();
        let fut = callback.call(app);
        // We are inside a synchronous call stack that originates from an async
        // tokio context.  `block_in_place` moves the current thread out of the
        // async worker pool temporarily so we can block on the future without
        // starving the runtime.
        tokio::task::block_in_place(|| tokio::runtime::Handle::current().block_on(fut))
    }
}

/// Events that can occur during skim's execution
#[derive(Clone, Debug)]
pub enum Event {
    /// Quit the application
    Quit,
    /// An error occurred
    Error(String),
    /// Close the application
    Close,
    /// Timer tick event
    Tick,
    /// Render the UI
    Render,
    /// A key was pressed
    Key(KeyEvent),
    /// Text was pasted (bracketed paste)
    Paste(String),
    /// A mouse event occurred
    Mouse(MouseEvent),
    /// Preview content is ready to display
    PreviewReady,
    /// Invalid input received
    InvalidInput,
    /// An action was triggered
    Action(Action),
    /// Append items to the pool
    AppendItems(Vec<Arc<dyn crate::SkimItem>>),
    /// Clear all items
    ClearItems,
    /// Clear the screen
    Clear,
    /// Heartbeat event
    Heartbeat,
    /// Run the preview command
    RunPreview,
    /// Run a command in the foreground, handing it the terminal
    ///
    /// Carries the already-expanded command line. Handled by the TUI event
    /// loop (which has access to the [`Tui`](crate::tui::Tui)) rather than by
    /// `handle_action`, because running a foreground process requires
    /// suspending skim's own input reader and toggling terminal modes.
    RunExecute(String),
    /// Redraw the screen
    Redraw,
    /// Reload with a new command
    Reload(String),
    /// Terminal was resized to (columns, rows)
    Resize(u16, u16),
}

/// Actions that can be performed in skim
#[derive(Debug, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "listen", derive(serde::Serialize, serde::Deserialize))]
pub enum Action {
    /// Abort and exit with error
    Abort,
    /// Accept selection and exit with optional key
    Accept(Option<String>),
    /// Add a character to the query
    AddChar(char),
    /// Append to selection and select
    AppendAndSelect,
    /// Move cursor backward one character
    BackwardChar,
    /// Delete character before cursor
    BackwardDeleteChar,
    /// Delete character before cursor or exit if the query is empty
    BackwardDeleteCharEof,
    /// Delete word before cursor
    BackwardKillWord,
    /// Move cursor backward one word
    BackwardWord,
    /// Move cursor to beginning of line
    BeginningOfLine,
    /// Bind one or more keys to action chains (`key:action[+action][,key:action…]`)
    Bind(String),
    /// Cancel current operation
    Cancel,
    /// Clear the screen
    ClearScreen,
    /// Delete character under cursor
    DeleteChar,
    /// Delete character or exit if empty
    DeleteCharEof,
    /// Deselect all items
    DeselectAll,
    /// Move selection down by N items
    Down(u16),
    /// Move cursor to end of line
    EndOfLine,
    /// Execute a command
    Execute(String),
    /// Execute a command silently
    ExecuteSilent(String),
    /// Jump to first item in list
    First,
    /// Move cursor forward one character
    ForwardChar,
    /// Move cursor forward one word
    ForwardWord,
    /// Execute action if query is empty
    IfQueryEmpty(String, Option<String>),
    /// Execute action if query is not empty
    IfQueryNotEmpty(String, Option<String>),
    /// Execute action if no items match
    IfNonMatched(String, Option<String>),
    /// Ignore the action
    Ignore,
    /// Delete from cursor to end of line
    KillLine,
    /// Delete word after cursor
    KillWord,
    /// Jump to last item in list
    Last,
    /// Move to next history entry
    NextHistory,
    /// Scroll down by half a page
    HalfPageDown(i32),
    /// Scroll up by half a page
    HalfPageUp(i32),
    /// Scroll down by a page
    PageDown(i32),
    /// Scroll up by a page
    PageUp(i32),
    /// Scroll preview up
    PreviewUp(i32),
    /// Scroll preview down
    PreviewDown(i32),
    /// Scroll preview left
    PreviewLeft(i32),
    /// Scroll preview right
    PreviewRight(i32),
    /// Scroll preview up by a page
    PreviewPageUp(i32),
    /// Scroll preview down by a page
    PreviewPageDown(i32),
    /// Move to previous history entry
    PreviousHistory,
    /// Redraw the screen
    Redraw,
    /// Refresh the command
    RefreshCmd,
    /// Refresh the preview
    RefreshPreview,
    /// Restart the matcher
    RestartMatcher,
    /// Reload with optional new command
    Reload(Option<String>),
    /// Rotate through matching modes
    RotateMode,
    /// Scroll item list left
    ScrollLeft(i32),
    /// Scroll item list right
    ScrollRight(i32),
    /// Select all items
    SelectAll,
    /// Select a specific row
    SelectRow(usize),
    /// Select current item
    Select,
    /// Suppress the default behaviour of the action this is bound to.
    ///
    /// Only meaningful as a follow-up bound to an action (e.g. `act-up:suppress`):
    /// it cancels that action's own effect, so the remaining follow-up chain
    /// runs in its place. On its own it is a no-op (equivalent to `ignore`).
    Suppress,
    /// Set the header (or disable it on an empty value)
    SetHeader(Option<String>),
    /// Set the preview cmd and rerun preview
    SetPreviewCmd(String),
    /// Set the query to the expanded value
    SetQuery(String),
    /// Toggle selection of current item
    Toggle,
    /// Toggle selection of all items
    ToggleAll,
    /// Toggle and move in
    ToggleIn,
    /// Toggle interactive mode
    ToggleInteractive,
    /// Toggle and move out
    ToggleOut,
    /// Toggle preview visibility
    TogglePreview,
    /// Toggle preview line wrapping
    TogglePreviewWrap,
    /// Toggle sorting
    ToggleSort,
    /// Jump to first item in list (alias for First)
    Top,
    /// Unbind one or more keys (`key[,key…]`)
    Unbind(String),
    /// Discard line (unix-style)
    UnixLineDiscard,
    /// Delete word backward (unix-style)
    UnixWordRubout,
    /// Move selection up by N items
    Up(u16),
    /// Yank (paste)
    Yank,
    /// Custom action from lib
    #[debug("custom")]
    #[eq(skip)]
    #[partial_eq(skip)]
    #[cfg_attr(feature = "listen", serde(skip))]
    Custom(ActionCallback),
}

fn parse_conditional(arg: Option<String>, constructor: fn(String, Option<String>) -> Action) -> Option<Action> {
    let arg = arg?;
    let (then, otherwise) = match arg.split_once('+') {
        Some((then, "")) => (then, None),
        Some((then, otherwise)) => (then, Some(otherwise.to_string())),
        None => (arg.as_str(), None),
    };
    Some(constructor(then.to_string(), otherwise))
}

macro_rules! define_action_catalog {
    ($arg:ident; $($pattern:pat => $name:literal => $parsed:expr),+ $(,)?) => {
        impl Action {
            /// Returns the canonical kebab-case name of this action — the same spelling
            /// [`parse_action`] accepts.
            ///
            /// This lets an action be bound as if it were an event (e.g. `reload:first`):
            /// after the action runs, any follow-up chain keyed by this name is queued.
            /// The name ignores the action's arguments, so `down` matches `Down(1)` and
            /// `Down(5)` alike.
            #[must_use]
            pub fn name(&self) -> &'static str {
                #[allow(clippy::enum_glob_use)]
                use Action::*;
                match self {
                    $($pattern => $name),+
                }
            }
        }

        fn parse_named_action(action: &str, $arg: Option<String>) -> Option<Action> {
            #[allow(clippy::enum_glob_use)]
            use Action::*;
            match action {
                $($name => $parsed),+,
                _ => None,
            }
        }
    };
}

define_action_catalog! {
    arg;
    Abort => "abort" => Some(Abort),
    Accept(_) => "accept" => Some(Accept(arg)),
    AddChar(_) => "add-char" => Some(AddChar(arg.unwrap_or_default().chars().next().unwrap_or_default())),
    AppendAndSelect => "append-and-select" => Some(AppendAndSelect),
    BackwardChar => "backward-char" => Some(BackwardChar),
    BackwardDeleteChar => "backward-delete-char" => Some(BackwardDeleteChar),
    BackwardDeleteCharEof => "backward-delete-char/eof" => Some(BackwardDeleteCharEof),
    BackwardKillWord => "backward-kill-word" => Some(BackwardKillWord),
    BackwardWord => "backward-word" => Some(BackwardWord),
    BeginningOfLine => "beginning-of-line" => Some(BeginningOfLine),
    Bind(_) => "bind" => Some(Bind(arg.unwrap_or_default())),
    Cancel => "cancel" => Some(Cancel),
    ClearScreen => "clear-screen" => Some(ClearScreen),
    DeleteChar => "delete-char" => Some(DeleteChar),
    DeleteCharEof => "delete-char/eof" => Some(DeleteCharEof),
    DeselectAll => "deselect-all" => Some(DeselectAll),
    Down(_) => "down" => Some(Down(arg.and_then(|s| s.parse().ok()).unwrap_or(1))),
    EndOfLine => "end-of-line" => Some(EndOfLine),
    Execute(_) => "execute" => Some(Execute(arg.unwrap_or_default())),
    ExecuteSilent(_) => "execute-silent" => Some(ExecuteSilent(arg.unwrap_or_default())),
    First => "first" => Some(First),
    ForwardChar => "forward-char" => Some(ForwardChar),
    ForwardWord => "forward-word" => Some(ForwardWord),
    IfQueryEmpty(..) => "if-query-empty" => parse_conditional(arg, IfQueryEmpty),
    IfQueryNotEmpty(..) => "if-query-not-empty" => parse_conditional(arg, IfQueryNotEmpty),
    IfNonMatched(..) => "if-non-matched" => parse_conditional(arg, IfNonMatched),
    Ignore => "ignore" => Some(Ignore),
    KillLine => "kill-line" => Some(KillLine),
    KillWord => "kill-word" => Some(KillWord),
    Last => "last" => Some(Last),
    NextHistory => "next-history" => Some(NextHistory),
    HalfPageDown(_) => "half-page-down" => Some(HalfPageDown(arg.and_then(|s| s.parse().ok()).unwrap_or(1))),
    HalfPageUp(_) => "half-page-up" => Some(HalfPageUp(arg.and_then(|s| s.parse().ok()).unwrap_or(1))),
    PageDown(_) => "page-down" => Some(PageDown(arg.and_then(|s| s.parse().ok()).unwrap_or(1))),
    PageUp(_) => "page-up" => Some(PageUp(arg.and_then(|s| s.parse().ok()).unwrap_or(1))),
    PreviewUp(_) => "preview-up" => Some(PreviewUp(arg.and_then(|s| s.parse().ok()).unwrap_or(1))),
    PreviewDown(_) => "preview-down" => Some(PreviewDown(arg.and_then(|s| s.parse().ok()).unwrap_or(1))),
    PreviewLeft(_) => "preview-left" => Some(PreviewLeft(arg.and_then(|s| s.parse().ok()).unwrap_or(1))),
    PreviewRight(_) => "preview-right" => Some(PreviewRight(arg.and_then(|s| s.parse().ok()).unwrap_or(1))),
    PreviewPageUp(_) => "preview-page-up" => Some(PreviewPageUp(arg.and_then(|s| s.parse().ok()).unwrap_or(1))),
    PreviewPageDown(_) => "preview-page-down" => Some(PreviewPageDown(arg.and_then(|s| s.parse().ok()).unwrap_or(1))),
    PreviousHistory => "previous-history" => Some(PreviousHistory),
    Redraw => "redraw" => Some(Redraw),
    RefreshCmd => "refresh-cmd" => Some(RefreshCmd),
    RefreshPreview => "refresh-preview" => Some(RefreshPreview),
    RestartMatcher => "restart-matcher" => Some(RestartMatcher),
    Reload(_) => "reload" => Some(Reload(arg)),
    RotateMode => "rotate-mode" => Some(RotateMode),
    ScrollLeft(_) => "scroll-left" => Some(ScrollLeft(arg.and_then(|s| s.parse().ok()).unwrap_or(1))),
    ScrollRight(_) => "scroll-right" => Some(ScrollRight(arg.and_then(|s| s.parse().ok()).unwrap_or(1))),
    SelectAll => "select-all" => Some(SelectAll),
    SelectRow(_) => "select-row" => Some(SelectRow(arg.and_then(|s| s.parse().ok()).unwrap_or_default())),
    Select => "select" => Some(Select),
    SetHeader(_) => "set-header" => Some(SetHeader(arg)),
    SetPreviewCmd(_) => "set-preview-cmd" => Some(SetPreviewCmd(arg.unwrap_or_default())),
    SetQuery(_) => "set-query" => Some(SetQuery(arg.unwrap_or_default())),
    Suppress => "suppress" => Some(Suppress),
    Toggle => "toggle" => Some(Toggle),
    ToggleAll => "toggle-all" => Some(ToggleAll),
    ToggleIn => "toggle-in" => Some(ToggleIn),
    ToggleInteractive => "toggle-interactive" => Some(ToggleInteractive),
    ToggleOut => "toggle-out" => Some(ToggleOut),
    TogglePreview => "toggle-preview" => Some(TogglePreview),
    TogglePreviewWrap => "toggle-preview-wrap" => Some(TogglePreviewWrap),
    ToggleSort => "toggle-sort" => Some(ToggleSort),
    Top => "top" => Some(Top),
    Unbind(_) => "unbind" => Some(Unbind(arg.unwrap_or_default())),
    UnixLineDiscard => "unix-line-discard" => Some(UnixLineDiscard),
    UnixWordRubout => "unix-word-rubout" => Some(UnixWordRubout),
    Up(_) => "up" => Some(Up(arg.and_then(|s| s.parse().ok()).unwrap_or(1))),
    Yank => "yank" => Some(Yank),
    Custom(_) => "custom" => None,
}

/// Parses an action string into an Action enum
///
/// Returns `None` if the action is unrecognized, or an `if-*` action is
/// specified without its required argument.
#[allow(clippy::too_many_lines)]
#[must_use]
pub fn parse_action(raw_action: &str) -> Option<Action> {
    let parts = raw_action.split_once([':', '(', ')']);
    let action;
    let mut arg = None;
    match parts {
        None => action = raw_action,
        Some((act, "")) => action = act,
        Some((act, a)) => {
            action = act;
            arg = Some(a.trim_end_matches(')').to_string());
        }
    }
    debug!("parse_action: action={action}, arg={arg:?}");

    if matches!(
        action,
        "add-char" | "bind" | "execute" | "execute-silent" | "set-preview-cmd" | "set-query" | "unbind"
    ) && arg.is_none()
    {
        None
    } else {
        parse_named_action(action, arg)
    }
}

#[cfg(test)]
#[path = "event_tests.rs"]
mod tests;