alma 0.1.1

//! Vim command-line state and parsing.

use bevy::prelude::Resource;

use super::error::VimError;
use crate::{StatusInfoText, presentation::TransparencyMode};

/// Maximum accepted `:` command length in Unicode scalar values.
const MAX_COMMAND_CHARS: usize = 256;

/// Command-line state for Vim `:` commands.
#[derive(Clone, Debug, Default, Eq, PartialEq, Resource)]
pub struct VimCommandState {
    /// Command text currently being edited after `:`.
    active_command: Option<VimCommandText>,
}

impl VimCommandState {
    /// Starts editing a `:` command.
    pub fn start(&mut self) {
        self.active_command = Some(VimCommandText::new());
    }

    /// Starts editing a `:` command prefilled with text.
    pub fn start_with(&mut self, text: &str) {
        let mut command = VimCommandText::new();
        command.push_str(text);
        self.active_command = Some(command);
    }

    /// Cancels active command editing.
    pub fn cancel(&mut self) {
        self.active_command = None;
    }

    /// Returns whether a command is being edited.
    #[must_use]
    pub const fn is_active(&self) -> bool {
        self.active_command.is_some()
    }

    /// Reads the active command, if any.
    #[must_use]
    pub const fn active_command(&self) -> Option<&VimCommandText> {
        self.active_command.as_ref()
    }

    /// Appends text to the active command.
    pub fn push_text(&mut self, text: &str) {
        if let Some(command) = &mut self.active_command {
            command.push_str(text);
        }
    }

    /// Deletes the previous scalar from the active command.
    pub fn backspace(&mut self) {
        if let Some(command) = &mut self.active_command {
            command.pop_char();
        }
    }

    /// Submits the active command for parsing.
    ///
    /// # Errors
    ///
    /// Returns [`VimError::NotAnEditorCommand`] when no command is active or when the command text
    /// is not one of the supported editor commands.
    pub fn submit(&mut self) -> Result<VimCommand, VimError> {
        let Some(command_text) = self.active_command.take() else {
            return Err(VimError::NotAnEditorCommand);
        };

        command_text.parse()
    }
}

/// User-provided text following a Vim `:` prompt.
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct VimCommandText {
    /// Raw command text, without the leading colon.
    text: String,
}

impl VimCommandText {
    /// Creates an empty command text value.
    #[must_use]
    pub const fn new() -> Self {
        Self {
            text: String::new(),
        }
    }

    /// Reads the command text.
    #[must_use]
    pub fn as_str(&self) -> &str {
        &self.text
    }

    /// Returns command text escaped for one-line status prompt rendering.
    #[must_use]
    pub fn status_text(&self) -> StatusInfoText {
        StatusInfoText::escaped_display(&self.text)
    }

    /// Appends text, truncating at the configured scalar limit.
    pub fn push_str(&mut self, text: &str) {
        let remaining = MAX_COMMAND_CHARS.saturating_sub(self.text.chars().count());
        self.text.extend(text.chars().take(remaining));
    }

    /// Removes the previous Unicode scalar value.
    pub fn pop_char(&mut self) {
        let _removed = self.text.pop();
    }

    /// Parses this command text as a supported Vim editor command.
    fn parse(self) -> Result<VimCommand, VimError> {
        parse_command(self.text.trim())
    }
}

/// Supported Vim editor commands.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum VimCommand {
    /// `:write` / `:w`.
    Write,
    /// `:quit` / `:q`.
    Quit(QuitPolicy),
    /// Write the file and quit.
    WriteQuit(WriteQuitPolicy),
    /// Change window and surface transparency mode.
    SetTransparency(TransparencyMode),
}

/// Quit behavior for commands that may discard changes.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum QuitPolicy {
    /// Refuse to quit when the buffer is modified.
    PreserveChanges,
    /// Quit even when the buffer is modified.
    Force,
}

/// Write behavior for commands that write and quit.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum WriteQuitPolicy {
    /// Always write before quitting, as `:wq` does.
    AlwaysWrite,
    /// Write only when the buffer is modified, as `:x` does.
    WriteIfModified,
}

/// Stable command identity used by the command catalog.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum CommandName {
    /// Write the current buffer.
    Write,
    /// Quit the editor.
    Quit,
    /// Write and quit.
    WriteQuit,
    /// Write-if-modified and quit.
    Exit,
    /// Change a typed editor option.
    Set,
}

/// Argument shape accepted by a catalog entry.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum CommandArgSchema {
    /// No arguments are accepted.
    None,
    /// One typed `:set` option value is accepted.
    SetTransparency,
}

/// Authority required to execute a parsed command.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum CommandAuthority {
    /// Writes through the persistence owner boundary and filesystem policy.
    BufferWrite,
    /// Requests lifecycle shutdown.
    Lifecycle,
    /// Writes through persistence policy and then requests lifecycle shutdown.
    BufferWriteAndLifecycle,
    /// Mutates presentation state.
    Presentation,
}

/// One catalog entry for a supported Vim command name.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct CommandSpec {
    /// Canonical command identity.
    name: CommandName,
    /// Accepted aliases, excluding generated policy variants such as `q!`.
    aliases: &'static [&'static str],
    /// Argument schema.
    args: CommandArgSchema,
    /// Authority required for execution.
    authority: CommandAuthority,
}

impl CommandSpec {
    /// Returns the canonical command identity.
    #[must_use]
    pub const fn name(self) -> CommandName {
        self.name
    }

    /// Returns accepted aliases.
    #[must_use]
    pub const fn aliases(self) -> &'static [&'static str] {
        self.aliases
    }

    /// Returns the argument schema.
    #[must_use]
    pub const fn args(self) -> CommandArgSchema {
        self.args
    }

    /// Returns the required authority class.
    #[must_use]
    pub const fn authority(self) -> CommandAuthority {
        self.authority
    }
}

/// Typed command catalog.
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct CommandCatalog;

impl CommandCatalog {
    /// Returns all supported command specs.
    #[must_use]
    pub const fn specs(&self) -> &'static [CommandSpec] {
        COMMAND_SPECS
    }

    /// Parses command text through the catalog.
    ///
    /// # Errors
    ///
    /// Returns [`VimError::NotAnEditorCommand`] when the name or argument
    /// shape is unsupported.
    pub fn parse(&self, text: &str) -> Result<VimCommand, VimError> {
        let text = text.trim();
        parse_force_variant(text)
            .or_else(|| parse_catalog_entry(text))
            .ok_or(VimError::NotAnEditorCommand)
    }
}

/// Built-in command catalog.
const COMMAND_SPECS: &[CommandSpec] = &[
    CommandSpec {
        name: CommandName::Write,
        aliases: &["w", "write"],
        args: CommandArgSchema::None,
        authority: CommandAuthority::BufferWrite,
    },
    CommandSpec {
        name: CommandName::Quit,
        aliases: &["q", "quit"],
        args: CommandArgSchema::None,
        authority: CommandAuthority::Lifecycle,
    },
    CommandSpec {
        name: CommandName::WriteQuit,
        aliases: &["wq"],
        args: CommandArgSchema::None,
        authority: CommandAuthority::BufferWriteAndLifecycle,
    },
    CommandSpec {
        name: CommandName::Exit,
        aliases: &["x", "xit", "exit"],
        args: CommandArgSchema::None,
        authority: CommandAuthority::BufferWriteAndLifecycle,
    },
    CommandSpec {
        name: CommandName::Set,
        aliases: &["set"],
        args: CommandArgSchema::SetTransparency,
        authority: CommandAuthority::Presentation,
    },
];

/// Parses supported Vim command names.
fn parse_command(text: &str) -> Result<VimCommand, VimError> {
    CommandCatalog.parse(text)
}

/// Parses force-style aliases that alter command policy.
fn parse_force_variant(text: &str) -> Option<VimCommand> {
    match text {
        "q!" | "quit!" => Some(VimCommand::Quit(QuitPolicy::Force)),
        "wq!" => Some(VimCommand::WriteQuit(WriteQuitPolicy::AlwaysWrite)),
        _ => None,
    }
}

/// Parses one catalog entry.
fn parse_catalog_entry(text: &str) -> Option<VimCommand> {
    let (name, argument) = split_command_name(text);
    let spec = COMMAND_SPECS
        .iter()
        .copied()
        .find(|spec| spec.aliases.contains(&name))?;

    match spec.name {
        CommandName::Write if argument.is_empty() => Some(VimCommand::Write),
        CommandName::Quit if argument.is_empty() => {
            Some(VimCommand::Quit(QuitPolicy::PreserveChanges))
        }
        CommandName::WriteQuit if argument.is_empty() => {
            Some(VimCommand::WriteQuit(WriteQuitPolicy::AlwaysWrite))
        }
        CommandName::Exit if argument.is_empty() => {
            Some(VimCommand::WriteQuit(WriteQuitPolicy::WriteIfModified))
        }
        CommandName::Set => parse_set_argument(argument),
        _ => None,
    }
}

/// Splits a command into name and untrusted argument tail.
fn split_command_name(text: &str) -> (&str, &str) {
    text.split_once(char::is_whitespace)
        .map_or((text, ""), |(name, argument)| (name, argument.trim()))
}

/// Parses supported `:set` arguments.
fn parse_set_argument(text: &str) -> Option<VimCommand> {
    parse_transparency_mode(text).map(VimCommand::SetTransparency)
}

/// Parses a user-facing transparency mode.
const fn parse_transparency_mode(text: &str) -> Option<TransparencyMode> {
    match text.as_bytes() {
        b"opaque" => Some(TransparencyMode::Opaque),
        b"transparent" => Some(TransparencyMode::Transparent),
        _ => None,
    }
}

#[cfg(test)]
mod tests {
    use super::{
        CommandArgSchema, CommandAuthority, CommandCatalog, CommandName, QuitPolicy, VimCommand,
        VimCommandState, VimCommandText, WriteQuitPolicy,
    };
    use crate::presentation::TransparencyMode;
    use crate::vim::VimError;

    #[test]
    fn parses_common_write_and_quit_commands() {
        assert_eq!(
            VimCommandText::new().parse(),
            Err(VimError::NotAnEditorCommand)
        );

        let mut command = VimCommandText::new();
        command.push_str("wq");
        assert_eq!(
            command.parse(),
            Ok(VimCommand::WriteQuit(WriteQuitPolicy::AlwaysWrite))
        );

        let mut command = VimCommandText::new();
        command.push_str("q!");
        assert_eq!(command.parse(), Ok(VimCommand::Quit(QuitPolicy::Force)));
    }

    #[test]
    fn command_state_submits_and_clears_active_command() {
        let mut state = VimCommandState::default();

        state.start();
        state.push_text("write");

        assert_eq!(state.submit(), Ok(VimCommand::Write));
        assert!(!state.is_active());
    }

    #[test]
    fn parses_transparency_commands() {
        let mut command = VimCommandText::new();
        command.push_str("set transparent");
        assert_eq!(
            command.parse(),
            Ok(VimCommand::SetTransparency(TransparencyMode::Transparent))
        );

        let mut command = VimCommandText::new();
        command.push_str("set opaque");
        assert_eq!(
            command.parse(),
            Ok(VimCommand::SetTransparency(TransparencyMode::Opaque))
        );

        let mut command = VimCommandText::new();
        command.push_str("set glass");
        assert_eq!(command.parse(), Err(VimError::NotAnEditorCommand));
    }

    #[test]
    fn command_catalog_exposes_typed_specs_and_authority() {
        let catalog = CommandCatalog;

        let write = catalog
            .specs()
            .iter()
            .find(|spec| spec.name() == CommandName::Write)
            .unwrap();
        assert_eq!(write.aliases(), &["w", "write"]);
        assert_eq!(write.args(), CommandArgSchema::None);
        assert_eq!(write.authority(), CommandAuthority::BufferWrite);

        let set = catalog
            .specs()
            .iter()
            .find(|spec| spec.name() == CommandName::Set)
            .unwrap();
        assert_eq!(set.args(), CommandArgSchema::SetTransparency);
        assert_eq!(set.authority(), CommandAuthority::Presentation);
    }
}