action.rs

use std::str::FromStr;

use cba::{
    StringError, bait::ResultExt, bring::split::split_on_delimiter_with_doubled_escape, unwrap,
};
use log::{debug, error};
use matchmaker::{
    Action, Actions,
    binds::Trigger,
    config::PartialRenderConfig,
    config_mm::{ConfigPreprocessedData, RangesFactory},
    event::BindSender,
    message::{BindDirective, Interrupt, RenderCommand},
    nucleo::Line,
    ui::StatusUI,
};
use matchmaker_partial::{Apply, Set};

use crate::config::SortSetting;
use crate::sort::{SortMode, apply_sort, expand_maybe_column, handle_sort_reverse};

pub type MMState<'a> = matchmaker::render::MMState<'a, String, ConfigPreprocessedData>;

#[derive(Debug, Clone, PartialEq)]
pub enum MMAction {
    // binds
    /// define a bind
    Bind(String),
    /// unset a bind
    Unbind(String),
    /// append actions to a bind
    PushBind(String),
    /// pop an action from a bind
    PopBind(String),

    // mode
    /// Replace the entire mode stack with the given comma-separated tags.
    SetMode(String),
    /// Push a single mode tag onto the mode stack.
    PushMode(String),
    /// Pop mode tags from the mode stack: empty pops the top tag, otherwise
    /// removes all occurrences of the given tag.
    PopMode(String),

    // state
    /// Toggle refiltering of results by query.
    Filtering(Option<bool>),
    /// Lexicographic sort by the active or given column.
    Sort(Option<usize>),
    /// Numeric sort.
    SortNumeric(Option<usize>),
    /// Reverse the non-match scoring function used in sorting. This is not the same as reversing the sort direction.
    SortReverse(Option<bool>),
    /// Set a threshold for result sorting (Empty/u32::MAX to ignore match scoring)
    SortThreshold(Option<u32>),
    /// Repopulate results using the next reload command declared in `start.additional_commands`
    ReloadNext(Option<usize>),
    /// Repopulate results using the previous reload command declared in `start.additional_commands`
    ReloadPrev,

    // set
    /// Set header
    SetHeader(Option<String>),
    /// Push header
    PushHeader(String),
    /// Set footer
    SetFooter(Option<String>),
    /// Push footer
    PushFooter(String),
    /// Set status without interpreting style braces
    SetPrompt(Option<String>),
    /// Set prompt
    SetStyledPrompt(String),
    /// Set status without interpreting style braces
    SetStatus(Option<String>),
    /// Set status
    SetStyledStatus(String),
    /// Run a command and display output in preview window
    RunPreview(String),
    /// Page the current preview command fullscreen (or an arbitrary command)
    /// in the pager; always resumes the picker afterwards
    ShowPreview(Option<String>),

    // copy
    /// Execute command and copy its output to the clipboard
    Copy(String),
    /// Execute command asynchronously and copy its output to the clipboard
    CopyAsync(String),

    // Unimplemented
    /// History up (TODO)
    HistoryUp,
    /// History down (TODO)
    HistoryDown,
    /// [`matchmaker::Action::Execute`], confirm on error
    ExecuteOrConfirm(String),
    /// [`matchmaker::Action::Execute`], quit on success
    ExecuteAndQuit(String),
    /// [`matchmaker::Action::Execute`], quit on success, confirm on error, resume on signal
    BecomeOrConfirm(String),
    /// [`matchmaker::Action::Execute`], quit on success, resume on error, exit on signal
    BecomeOrResume(String),
    /// Execute command and parse output as actions
    Transform(String),
    /// Execute command and parse output as configuration
    TransformConfig(String),
}

#[cfg(feature = "mlua")]
#[cfg(test)]
impl MMAction {
    /// Returns the execution or command payload of this action, if any.
    pub fn payload(&self) -> Option<&str> {
        match self {
            Self::ExecuteOrConfirm(s)
            | Self::ExecuteAndQuit(s)
            | Self::BecomeOrConfirm(s)
            | Self::BecomeOrResume(s)
            | Self::Transform(s)
            | Self::TransformConfig(s)
            | Self::Copy(s)
            | Self::CopyAsync(s)
            | Self::RunPreview(s) => Some(s.as_str()),
            Self::ShowPreview(s) => s.as_deref(),
            _ => None,
        }
    }

    /// Validates the Lua syntax of this action's payload if it is a Lua script.
    ///
    /// Returns:
    /// - `Some(true)` if the action contains a Lua payload with valid syntax.
    /// - `Some(false)` if the action contains a Lua payload with syntax errors.
    /// - `None` if the action is not a Lua script (or if the `mlua` feature is disabled).
    pub fn validate_lua(&self) -> Option<bool> {
        let payload = self.payload()?;
        #[cfg(feature = "mlua")]
        {
            match crate::execute::classify(payload) {
                crate::execute::CommandStrategy::Lua(code) => {
                    let lua = mlua::Lua::new();
                    match lua.load(&code).into_function() {
                        Ok(_) => Some(true),
                        Err(e) => {
                            log::error!("Lua syntax error: {e}");
                            Some(false)
                        }
                    }
                }
                crate::execute::CommandStrategy::LuaFile { path, .. } => {
                    if let Ok(src) = std::fs::read_to_string(&path) {
                        let lua = mlua::Lua::new();
                        match lua.load(&src).into_function() {
                            Ok(_) => Some(true),
                            Err(e) => {
                                log::error!(
                                    "Lua file syntax error in {}: {e}",
                                    path.to_string_lossy()
                                );
                                Some(false)
                            }
                        }
                    } else {
                        None
                    }
                }
                _ => None,
            }
        }
        #[cfg(not(feature = "mlua"))]
        None
    }
}

pub struct ActionContext {
    pub bind_tx: BindSender<MMAction>,
    pub render_tx: matchmaker::event::RenderSender<MMAction>,
    pub additional_commands: (Vec<String>, usize),
    /// Factory producing per-column range lookups. See [`matchmaker::config_mm::RangesFactory`].
    pub ranges_fn: RangesFactory<String>,
    /// Active custom sort settings. Seeded from `matcher.sort` and mutated by
    /// the `Sort`/`SortNumeric`/`SortReverse` actions.
    pub sort: SortSetting,
    /// Whether OSC 52 clipboard copying is enabled. Used to select the
    /// `Copy`/`CopyAsync` handler discriminant (1 = host clipboard, 0 = CLIPcmd).
    pub osc52: bool,
    // pub output_template: Option<String>,
    // pub print_handle: AppendOnly<String>,
    // pub output_separator: String,
}

pub fn action_handler(
    a: MMAction,
    state: &mut MMState<'_>,
    ActionContext {
        bind_tx,
        render_tx,
        additional_commands,
        ranges_fn,
        sort,
        osc52,
    }: &mut ActionContext,
) {
    match a {
        // state
        MMAction::Filtering(s) => state.picker_ui.set_filtering(s),

        // history
        MMAction::HistoryUp => {
            // todo
        }
        MMAction::HistoryDown => {
            // todo
        }

        MMAction::ReloadNext(x) => {
            if additional_commands.0.is_empty() {
                return;
            }

            let index = match x {
                None => {
                    additional_commands.1 =
                        (additional_commands.1 + 1) % additional_commands.0.len();
                    additional_commands.1
                }
                Some(x) => {
                    if x < additional_commands.0.len() {
                        x
                    } else {
                        error!("Index {x} is out of bounds for ReloadNext");
                        return;
                    }
                }
            };
            let payload = &additional_commands.0[index];
            state.envs.set("MM_INDEX", index);
            state.set_interrupt(Interrupt::Reload, payload.clone());
        }

        MMAction::ReloadPrev => {
            if additional_commands.0.is_empty() {
                return;
            }

            additional_commands.1 = (additional_commands.1 + additional_commands.0.len() - 1)
                % additional_commands.0.len();

            let index = additional_commands.1;

            let payload = &additional_commands.0[index];

            state.envs.set("MM_INDEX", index);

            state.set_interrupt(Interrupt::Reload, payload.clone());
        }

        // sort
        MMAction::Sort(idx) => {
            let Some(n) = expand_maybe_column(state, idx) else {
                return;
            };
            apply_sort(state, ranges_fn, n, SortMode::Lexicographic, sort);
        }
        MMAction::SortNumeric(idx) => {
            let Some(n) = expand_maybe_column(state, idx) else {
                return;
            };
            apply_sort(state, ranges_fn, n, SortMode::Numeric, sort);
        }
        MMAction::SortReverse(dir) => {
            handle_sort_reverse(state, dir, sort);
        }
        MMAction::SortThreshold(threshold) => {
            state
                .picker_ui
                .worker
                .set_stability(threshold.unwrap_or(u32::MAX));
        }

        // binds
        MMAction::Bind(s) => {
            let (trigger, values) = unwrap!(parse_bind_parts(&s)._elog());
            let _ = bind_tx.send(BindDirective::Bind(trigger, values));
        }
        MMAction::Unbind(s) => {
            let trigger = unwrap!(s.parse()._elog());
            let _ = bind_tx.send(BindDirective::Unbind(trigger));
        }
        MMAction::PushBind(s) => {
            let (trigger, action) = unwrap!(parse_push_bind_parts(&s)._elog());
            let _ = bind_tx.send(BindDirective::PushBind(trigger, action));
        }
        MMAction::PopBind(s) => {
            let trigger = unwrap!(s.parse()._elog());
            let _ = bind_tx.send(BindDirective::PopBind(trigger));
        }

        // mode
        MMAction::SetMode(s) => {
            let _ = bind_tx.send(BindDirective::SetMode(s));
        }
        MMAction::PushMode(s) => {
            let _ = bind_tx.send(BindDirective::PushMode(s));
        }
        MMAction::PopMode(s) => {
            let _ = bind_tx.send(BindDirective::PopMode(s));
        }

        // set
        MMAction::SetHeader(context) => {
            if let Some(s) = context {
                state.picker_ui.header.set(s);
            } else {
                state.picker_ui.header.clear(true);
            }
        }
        MMAction::PushHeader(s) => {
            state.picker_ui.header.push(s);
        }
        MMAction::SetFooter(context) => {
            if let Some(s) = context {
                state.footer_ui.set(s);
            } else {
                state.footer_ui.clear(false);
            }
        }
        MMAction::PushFooter(s) => {
            state.footer_ui.push(s);
        }
        MMAction::SetStyledPrompt(s) => {
            state
                .picker_ui
                .query
                .set_prompt(Some(StatusUI::parse_template_to_status_line(&s)));
        }
        MMAction::SetStyledStatus(s) => {
            state
                .picker_ui
                .status
                .set(Some(StatusUI::parse_template_to_status_line(&s)));
        }
        MMAction::SetStatus(s) => {
            state.picker_ui.status.set(s.map(Line::raw));
        }
        MMAction::SetPrompt(s) => {
            state.picker_ui.query.set_prompt(s.map(Line::raw));
        }
        MMAction::RunPreview(cmd) => {
            if cmd.is_empty() {
                let template = state
                    .preview_set_payload()
                    .as_ref()
                    .and_then(|p| p.as_ref().ok().map(|s| s.to_string()))
                    .unwrap_or_else(|| state.preview_payload().clone());
                state.discriminant_payload = Some(5);
                state.set_interrupt(Interrupt::Execute, template);
            } else if let Some(p) = state.preview_ui {
                p.show(true);
                state.update_preview_set(Ok(cmd));
            }
        }
        MMAction::ShowPreview(opt) => {
            // Page the current preview command (or an arbitrary template)
            // fullscreen. Payload-less ShowPreview uses whatever the preview
            // would currently display. The pager branch runs inside the
            // Execute interrupt handler (discriminant 4).
            state.discriminant_payload = Some(4);
            if let Some(cmd) = opt {
                state.set_interrupt(Interrupt::Execute, cmd);
            } else {
                let template = state
                    .preview_set_payload()
                    .as_ref()
                    .and_then(|p| p.as_ref().ok().map(|s| s.to_string()))
                    .unwrap_or_else(|| state.preview_payload().clone());
                state.set_interrupt(Interrupt::Execute, template);
            }
        }
        MMAction::Copy(s) => {
            state.discriminant_payload = Some(if *osc52 { 1 } else { 0 });
            state.set_interrupt(Interrupt::ExecuteSilent, s);
        }
        MMAction::CopyAsync(s) => {
            state.discriminant_payload = Some(if *osc52 { 1 } else { 0 });
            state.set_interrupt(Interrupt::ExecuteAsync, s);
        }
        MMAction::ExecuteOrConfirm(s) => {
            state.discriminant_payload = Some(0);
            state.set_interrupt(Interrupt::Execute, s);
        }
        MMAction::ExecuteAndQuit(s) => {
            state.discriminant_payload = Some(1);
            state.set_interrupt(Interrupt::Execute, s);
        }
        MMAction::BecomeOrConfirm(s) => {
            state.discriminant_payload = Some(2);
            state.set_interrupt(Interrupt::Execute, s);
        }
        MMAction::BecomeOrResume(s) => {
            state.discriminant_payload = Some(3);
            state.set_interrupt(Interrupt::Execute, s);
        }
        MMAction::Transform(payload) => {
            let vars = state.make_env_vars();
            let Some(strategy) = crate::execute::classify(&payload)
                .template(state)
                .and_then(|s| s.resolve_relative(&vars)._elog())
            else {
                return;
            };
            #[cfg(feature = "mlua")]
            let lua_state = crate::lua::LuaState::from_mm(state);
            let contents = crate::execute::run_capture(
                &strategy,
                &vars,
                #[cfg(feature = "mlua")]
                &lua_state,
            );

            let render_tx = render_tx.clone();
            if let Some(contents) = contents {
                debug!("Transform output:\n{}", contents);

                for line in contents.lines() {
                    match Action::<MMAction>::from_str(line) {
                        Ok(action) => {
                            let _ = render_tx.send(RenderCommand::Action(action));
                        }
                        Err(_) => {
                            error!("Failed to parse action from transform output: {}", line);
                        }
                    }
                }
            }
        }
        MMAction::TransformConfig(payload) => {
            let vars = state.make_env_vars();
            let Some(strategy) = crate::execute::classify(&payload)
                .template(state)
                .and_then(|s| s.resolve_relative(&vars)._elog())
            else {
                return;
            };
            #[cfg(feature = "mlua")]
            let lua_state = crate::lua::LuaState::from_mm(state);
            let contents = crate::execute::run_capture(
                &strategy,
                &vars,
                #[cfg(feature = "mlua")]
                &lua_state,
            );

            if let Some(contents) = contents {
                debug!("TransformConfig output:\n{}", contents);

                let words: Vec<String> = contents.lines().map(|s| s.to_string()).collect();
                match crate::parse::get_pairs(words) {
                    Ok(pairs) => {
                        let mut partial = PartialRenderConfig::default();
                        for (path, val) in pairs {
                            let mut parts = split_on_delimiter_with_doubled_escape(&val, ',');
                            if let Err(e) = crate::parse::try_split_kv(&mut parts, false) {
                                error!("Failed to split KV for {}: {e}", path.join("."));
                                continue;
                            }

                            if let Err(e) = partial.set(path.as_slice(), &parts) {
                                error!("Failed to set partial for {}: {e}", path.join("."));
                            }
                        }

                        log::debug!("Parsed config update: {partial:?}");

                        // Apply the partial to UI components
                        state.ui.config.apply(partial.ui);
                        state.picker_ui.query.config.apply(partial.query);
                        state.picker_ui.results.config.apply(partial.results);
                        state.picker_ui.status.status_config.apply(partial.status);
                        state.footer_ui.config.apply(partial.footer);
                        state.picker_ui.header.config.apply(partial.header);

                        if let Some(preview_ui) = state.preview_ui.as_mut() {
                            preview_ui.config.apply(partial.preview);
                        }

                        let _ = render_tx.send(RenderCommand::Refresh);
                    }
                    Err(e) => {
                        error!("Failed to parse pairs from TransformConfig output: {e}");
                    }
                }
            }
        }
    }
}

impl MMAction {
    /// Validate Bind/PushBind/Unbind/PopBind instructions
    pub fn validate(&self) -> Result<(), StringError> {
        match self {
            MMAction::Bind(s) => {
                let (_trigger, actions) = parse_bind_parts(s)?;
                for a in &actions {
                    if let Action::Custom(mm) = a {
                        mm.validate()?;
                    }
                }
            }
            MMAction::PushBind(s) => {
                let (_trigger, a) = parse_push_bind_parts(s)?;
                if let Action::Custom(mm) = &a {
                    mm.validate()?;
                }
            }
            MMAction::Unbind(s) | MMAction::PopBind(s) => {
                s.parse::<Trigger>()?;
            }
            _ => {}
        }
        Ok(())
    }
}

pub fn parse_bind_parts(s: &str) -> Result<(Trigger, Actions<MMAction>), StringError> {
    let (trigger, values) = s
        .split_once('=')
        .ok_or_else(|| format!("Expected '=' in Bind({s})"))?;

    let trigger = trigger.trim().parse()?;

    let parts = split_on_delimiter_with_doubled_escape(values, ',');

    let actions = parts
        .iter()
        .map(|p| Action::<MMAction>::from_str(p.trim()))
        .collect::<Result<Vec<_>, _>>()?;

    Ok((trigger, Actions::from_iter(actions)))
}

pub fn parse_push_bind_parts(s: &str) -> Result<(Trigger, Action<MMAction>), StringError> {
    let s = s.trim();
    let (trigger, values) = s
        .split_once('=')
        .ok_or_else(|| format!("Expected '=' in PushBind({s})"))?;

    let trigger = trigger.trim().parse()?;
    let action = Action::<MMAction>::from_str(values.trim())?;

    Ok((trigger, action))
}

enum_from_str_display! {
    MMAction;

    units:
    HistoryUp, HistoryDown, ReloadPrev;


    tuples:
    Bind, Unbind, PushBind, PopBind, SetMode, PushMode, ExecuteOrConfirm, ExecuteAndQuit, BecomeOrConfirm, BecomeOrResume, Transform, TransformConfig, SetStyledPrompt, SetStyledStatus, PushHeader, PushFooter,
    Copy, CopyAsync;

    defaults:
    (PopMode, String::new()), (RunPreview, String::new());

    options:
    SetPrompt, SetHeader, SetFooter, SetStatus, Filtering, ReloadNext, Sort, SortNumeric, SortReverse, SortThreshold, ShowPreview;

    lossy:
    ;
}

//------------------------------------------------
macro_rules! enum_from_str_display {
    (
        $enum:ty;
        units: $( $unit:ident ),* $(,)?;
        tuples: $( $tuple:ident ),* $(,)?;
        defaults: $(($default:ident, $default_value:expr)),*;
        options: $($optional:ident),*;
        lossy: $( $lossy:ident ),* ;
    ) => {
        impl std::fmt::Display for $enum {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                use $enum::*;
                match self {
                    $( $unit => write!(f, stringify!($unit)), )*

                    $( $tuple(inner) => write!(f, concat!(stringify!($tuple), "({})"), inner), )*

                    $( $default(inner) => {
                        if *inner == $default_value {
                            write!(f, stringify!($default))
                        } else {
                            write!(f, concat!(stringify!($default), "({})"), inner)
                        }
                    }, )*

                    $( $optional(opt) => {
                        if let Some(inner) = opt {
                            write!(f, concat!(stringify!($optional), "({})"), inner)
                        } else {
                            write!(f, stringify!($optional))
                        }
                    }, )*

                    $( $lossy(inner) => {
                        if inner.is_empty() {
                            write!(f, stringify!($pathbuf))
                        } else {
                            write!(f, concat!(stringify!($lossy), "({})"), std::ffi::OsString::from(inner).to_string_lossy())
                        }
                    }, )*

                    /* ---------- Manually parsed ---------- */

                    /* ------------------------------------- */

                }
            }
        }

        impl std::str::FromStr for $enum {
            type Err = String;

            fn from_str(s: &str) -> Result<Self, Self::Err> {
                let (name, data) = if let Some(pos) = s.find('(') {
                    if s.ends_with(')') {
                        (&s[..pos], Some(&s[pos + 1..s.len() - 1]))
                    } else {
                        (s, None)
                    }
                } else {
                    (s, None)
                };

                match name {
                    $( stringify!($unit) => {
                        if data.is_some() {
                            Err(format!("Unexpected data for {}", name))
                        } else {
                            Ok(Self::$unit)
                        }
                    }, )*

                    $( stringify!($tuple) => {
                        let val = data
                        .ok_or_else(|| format!("Missing data for {}", name))?
                        .parse()
                        .map_err(|_| format!("Invalid data for {}", name))?;
                        Ok(Self::$tuple(val))
                    }, )*

                    $( stringify!($lossy) => {
                        let d = match data {
                            Some(val) => val.parse()
                            .map_err(|_| format!("Invalid data for {}", stringify!($lossy)))?,
                            None => Default::default(),
                        };
                        Ok(Self::$lossy(d))
                    }, )*

                    $( stringify!($default) => {
                        let d = match data {
                            Some(val) => val.parse()
                            .map_err(|_| format!("Invalid data for {}", stringify!($default)))?,
                            None => $default_value,
                        };
                        Ok(Self::$default(d))
                    }, )*

                    $( stringify!($optional) => {
                        let d = match data {
                            Some(val) if !val.is_empty() => {
                                Some(val.parse().map_err(|_| format!("Invalid data for {}", stringify!($optional)))?)
                            }
                            _ => None,
                        };
                        Ok(Self::$optional(d))
                    }, )*

                    /* ---------- Manually parsed ---------- */

                    /* ------------------------------------- */

                    _ => Err("".to_string()),
                }
            }
        }
    };
}
use enum_from_str_display;

#[cfg(test)]
mod tests {
    use super::*;
    use matchmaker::Action;

    #[test]
    fn test_parse_actions() {
        assert!(Action::<MMAction>::from_str("Unbind(QueryChange)").is_ok());
        assert!(Action::<MMAction>::from_str("Filtering(false)").is_ok());
        assert!(Action::<MMAction>::from_str("SetPrompt(rg> )").is_ok());
        assert!(Action::<MMAction>::from_str("Reload").is_ok());

        let bind_inner = match Action::<MMAction>::from_str(
            "Bind(QueryChange = Reload(rg --column --line-number --no-heading --color=always --smart-case \"$FZF_QUERY\"))",
        )
        .unwrap()
        {
            Action::Custom(MMAction::Bind(s)) => s,
            _ => panic!(),
        };

        let (_trigger, actions) = parse_bind_parts(&bind_inner).unwrap();
        assert_eq!(actions.len(), 1);
        match &actions[0] {
            Action::Reload(cmd) => assert_eq!(
                cmd,
                "rg --column --line-number --no-heading --color=always --smart-case \"$FZF_QUERY\""
            ),
            _ => panic!(),
        }

        let push_inner = match Action::<MMAction>::from_str("PushBind(ctrl-r = @enter_mm)").unwrap()
        {
            Action::Custom(MMAction::PushBind(s)) => s,
            _ => panic!(),
        };

        let (_trigger, action) = parse_push_bind_parts(&push_inner).unwrap();
        assert_eq!(action, Action::Semantic("enter_mm".into()));
    }

    #[test]
    fn test_validate_lua() {
        let non_lua = MMAction::ExecuteOrConfirm("echo hello".into());
        assert_eq!(non_lua.validate_lua(), None);

        #[cfg(feature = "mlua")]
        {
            let valid_lua = MMAction::ExecuteOrConfirm("#!lua return 1 + 1".into());
            assert_eq!(valid_lua.validate_lua(), Some(true));

            let invalid_lua = MMAction::ExecuteOrConfirm("#!lua return 1 +".into());
            assert_eq!(invalid_lua.validate_lua(), Some(false));

            let copy_lua = MMAction::CopyAsync("#!lua local t = {}; return table.concat(t)".into());
            assert_eq!(copy_lua.validate_lua(), Some(true));
        }
    }

    #[test]
    fn test_parse_run_preview() {
        assert_eq!(
            Action::<MMAction>::from_str("RunPreview").unwrap(),
            Action::Custom(MMAction::RunPreview(String::new()))
        );
        assert_eq!(
            Action::<MMAction>::from_str("RunPreview()").unwrap(),
            Action::Custom(MMAction::RunPreview(String::new()))
        );
        assert_eq!(
            Action::<MMAction>::from_str("RunPreview(echo foo)").unwrap(),
            Action::Custom(MMAction::RunPreview("echo foo".into()))
        );
    }
}