vorto 0.13.0-beta.2

//! Editor-wide settings — currently just indent geometry.
//!
//! The same field set surfaces in two places in the TOML schema:
//!
//! * `[editor]` at the top level — the global default.
//! * Flattened into each `[languages.<name>]` table — per-language
//!   overrides. Any field unset there falls through to the global
//!   default; any field set wins. Field-level merge.

use serde::Deserialize;
use serde::de::{self, Deserializer, Visitor};

const DEFAULT_INDENT_WIDTH: usize = 2;
const DEFAULT_TAB_WIDTH: usize = 4;

/// How the autoreload watcher reacts when the active buffer's backing
/// file changes on disk underneath it (formatter, agent, `git checkout`,
/// another editor).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AutoreloadMode {
    /// Watcher off — drift is only picked up by an explicit `:reload`.
    None,
    /// Detect drift and open a "Reload it?" confirmation before replacing
    /// the buffer wholesale. The historical default.
    Replace,
    /// Follow the external edit automatically. A clean buffer reloads
    /// silently; a buffer with unsaved edits gets a three-way merge,
    /// landing `<<<<<<<` conflict markers only where both sides touched
    /// the same lines.
    Merge,
}

/// Accepts either the legacy boolean (`true` → [`AutoreloadMode::Replace`],
/// `false` → [`AutoreloadMode::None`]) or one of the string forms
/// `"none"` / `"replace"` / `"merge"`, so configs written against the old
/// `autoreload = true/false` schema keep working.
impl<'de> Deserialize<'de> for AutoreloadMode {
    fn deserialize<D>(d: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct ModeVisitor;
        impl Visitor<'_> for ModeVisitor {
            type Value = AutoreloadMode;
            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
                f.write_str(r#"a boolean or one of "none", "replace", "merge""#)
            }
            fn visit_bool<E: de::Error>(self, b: bool) -> Result<AutoreloadMode, E> {
                Ok(if b {
                    AutoreloadMode::Replace
                } else {
                    AutoreloadMode::None
                })
            }
            fn visit_str<E: de::Error>(self, s: &str) -> Result<AutoreloadMode, E> {
                match s {
                    "none" | "off" => Ok(AutoreloadMode::None),
                    "replace" | "prompt" => Ok(AutoreloadMode::Replace),
                    "merge" => Ok(AutoreloadMode::Merge),
                    other => Err(de::Error::unknown_variant(
                        other,
                        &["none", "replace", "merge"],
                    )),
                }
            }
        }
        d.deserialize_any(ModeVisitor)
    }
}

/// Visual style for the indent-guide bars.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
pub enum IndentGuideStyle {
    /// Plain vertical bar (`│`) on every guide cell. The active
    /// scope's bar is bold.
    #[serde(rename = "line")]
    Line,
    /// powerlevel10k–style: the active scope gets a top corner
    /// (`╭─`) at its first body row and a turn-arrow (`╰─>`) at
    /// the cursor row, with `│` connecting them.
    #[serde(rename = "p10k")]
    P10k,
}

/// Raw, optional fields as parsed from TOML. Used both for the global
/// `[editor]` table and (via `#[serde(flatten)]`) inside each
/// `[languages.<name>]` table for per-language overrides.
#[derive(Debug, Default, Clone, Deserialize)]
pub struct EditorToml {
    /// Width of one indent level — number of columns the editor uses
    /// when it indents a line. Falls back to `2` when unset.
    pub indent_width: Option<usize>,
    /// Visual width of a literal `\t` character. Falls back to `4` when
    /// unset; Go-style codebases typically want `8`.
    pub tab_width: Option<usize>,
    /// When `true`, auto-inserted indents (newline carry, opener-bracket
    /// level bump) use `\t`; when `false`, they use `indent_width`
    /// spaces. Falls back to `false`. Per-language override is the usual
    /// way to flip this on (e.g. Go).
    pub use_tabs: Option<bool>,
    /// When `true`, spaces and tabs in the buffer are rendered with
    /// visible marker glyphs (middle-dot / arrow) drawn in a dim
    /// foreground. Falls back to `false`.
    pub show_whitespace: Option<bool>,
    /// When `true`, save runs the configured formatter (external command
    /// if `formatter = {…}` is set, otherwise `textDocument/formatting`
    /// against the first attached LSP) before writing to disk. Falls back
    /// to `true`. Per-language overrides flatten the same field into the
    /// `[languages.<name>]` table.
    pub format_on_save: Option<bool>,
    /// How the active pane's file-backed buffer reacts to an external
    /// edit (mtime/len drift from the load/save baseline), polled on a
    /// timer while the terminal is focused. `"replace"` (the default)
    /// opens a "Reload it?" confirmation; `"merge"` follows the edit
    /// automatically via a three-way merge; `"none"` disables the watcher
    /// (only `:reload` picks up drift). The legacy booleans still parse:
    /// `true` → `"replace"`, `false` → `"none"`. Per-language overrides
    /// flatten the same field into `[languages.<name>]`.
    pub autoreload: Option<AutoreloadMode>,
    /// When `true`, draws vertical guide lines at each indentation level
    /// in the buffer. The level containing the cursor is painted in a
    /// distinct color. Falls back to `true`.
    pub indent_guides: Option<bool>,
    /// Number of shallowest indent levels to suppress when drawing
    /// guides. `0` (the default) shows every level; `1` hides the
    /// leftmost guide globally; `2` hides the two shallowest, etc.
    /// Applied per visible window — when the deepest visible
    /// nesting is shallower than `skip_levels` the file shows no
    /// guides at all, so prefer `0` for buffers that may stay
    /// shallow most of the time.
    pub indent_guides_skip_levels: Option<usize>,
    /// Visual style for indent guides. `"line"` (the default) draws
    /// `│` everywhere; `"p10k"` decorates the active scope with
    /// powerlevel10k–style corner/arrow glyphs.
    pub indent_guide_style: Option<IndentGuideStyle>,
    /// When `true`, the active indent-guide (bar in `line` mode,
    /// bracket in `p10k`) expands from the cursor row outward to
    /// the scope boundaries each time the cursor enters a new
    /// scope. Falls back to `false`.
    pub indent_animation: Option<bool>,
    /// Duration of the active-guide expand animation, in
    /// milliseconds. Ignored unless `indent_animation = true`.
    /// Falls back to `150`.
    pub indent_animation_ms: Option<u64>,
    /// `<space>e` explorer: when `true`, the picker groups matches by
    /// parent directory with a header line per group and the file
    /// basename indented underneath. When `false`, the explorer
    /// degenerates to a flat path list (same shape as the fuzzy-files
    /// picker), which is what users who'd rather keep one row per
    /// match want. Falls back to `true`.
    pub compact_folders: Option<bool>,
}

/// Fully-resolved editor settings — what the runtime actually reads
/// after the user TOML has been overlaid on the built-in defaults.
#[derive(Debug, Clone, Copy)]
pub struct EditorConfig {
    pub indent_width: usize,
    pub tab_width: usize,
    pub use_tabs: bool,
    pub show_whitespace: bool,
    pub format_on_save: bool,
    pub autoreload: AutoreloadMode,
    pub indent_guides: bool,
    pub indent_guides_skip_levels: usize,
    pub indent_guide_style: IndentGuideStyle,
    pub indent_animation: bool,
    pub indent_animation_ms: u64,
    pub compact_folders: bool,
}

impl Default for EditorConfig {
    fn default() -> Self {
        Self {
            indent_width: DEFAULT_INDENT_WIDTH,
            tab_width: DEFAULT_TAB_WIDTH,
            use_tabs: false,
            show_whitespace: false,
            format_on_save: true,
            autoreload: AutoreloadMode::Replace,
            indent_guides: true,
            indent_guides_skip_levels: 0,
            indent_guide_style: IndentGuideStyle::Line,
            indent_animation: false,
            indent_animation_ms: 100,
            compact_folders: true,
        }
    }
}

impl EditorConfig {
    /// Field-level overlay: any `Some(_)` in `user` wins, the rest of
    /// `self` survives. Used to layer per-language overrides on top of
    /// the global default.
    pub fn overlay(self, user: &EditorToml) -> Self {
        Self {
            indent_width: user.indent_width.unwrap_or(self.indent_width),
            tab_width: user.tab_width.unwrap_or(self.tab_width),
            use_tabs: user.use_tabs.unwrap_or(self.use_tabs),
            show_whitespace: user.show_whitespace.unwrap_or(self.show_whitespace),
            format_on_save: user.format_on_save.unwrap_or(self.format_on_save),
            autoreload: user.autoreload.unwrap_or(self.autoreload),
            indent_guides: user.indent_guides.unwrap_or(self.indent_guides),
            indent_guides_skip_levels: user
                .indent_guides_skip_levels
                .unwrap_or(self.indent_guides_skip_levels),
            indent_guide_style: user.indent_guide_style.unwrap_or(self.indent_guide_style),
            indent_animation: user.indent_animation.unwrap_or(self.indent_animation),
            indent_animation_ms: user.indent_animation_ms.unwrap_or(self.indent_animation_ms),
            compact_folders: user.compact_folders.unwrap_or(self.compact_folders),
        }
    }
}

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

    #[test]
    fn defaults_when_user_omits_fields() {
        let eff = EditorConfig::default().overlay(&EditorToml::default());
        assert_eq!(eff.indent_width, 2);
        assert_eq!(eff.tab_width, 4);
    }

    #[test]
    fn overlay_replaces_only_provided_fields() {
        let base = EditorConfig {
            indent_width: 4,
            tab_width: 4,
            use_tabs: false,
            show_whitespace: false,
            format_on_save: true,
            autoreload: AutoreloadMode::Replace,
            indent_guides: true,
            indent_guides_skip_levels: 0,
            indent_guide_style: IndentGuideStyle::Line,
            indent_animation: false,
            indent_animation_ms: 150,
            compact_folders: true,
        };
        let eff = base.overlay(&EditorToml {
            tab_width: Some(8),
            ..Default::default()
        });
        assert_eq!(eff.indent_width, 4);
        assert_eq!(eff.tab_width, 8);
    }

    fn parse_autoreload(toml_src: &str) -> Option<AutoreloadMode> {
        toml::from_str::<EditorToml>(toml_src).unwrap().autoreload
    }

    #[test]
    fn autoreload_accepts_legacy_booleans() {
        assert_eq!(
            parse_autoreload("autoreload = true"),
            Some(AutoreloadMode::Replace)
        );
        assert_eq!(
            parse_autoreload("autoreload = false"),
            Some(AutoreloadMode::None)
        );
    }

    #[test]
    fn autoreload_accepts_mode_strings() {
        assert_eq!(
            parse_autoreload(r#"autoreload = "none""#),
            Some(AutoreloadMode::None)
        );
        assert_eq!(
            parse_autoreload(r#"autoreload = "replace""#),
            Some(AutoreloadMode::Replace)
        );
        assert_eq!(
            parse_autoreload(r#"autoreload = "merge""#),
            Some(AutoreloadMode::Merge)
        );
    }

    #[test]
    fn autoreload_rejects_unknown_string() {
        assert!(toml::from_str::<EditorToml>(r#"autoreload = "sometimes""#).is_err());
    }
}