ezpn 0.11.1

use crate::daemon::hooks::HookDef;
use crate::render::BorderStyle;
use crate::settings::Settings;
use std::path::PathBuf;

/// Runtime config merged from: defaults < config file < CLI args.
pub struct EzpnConfig {
    pub border: BorderStyle,
    pub shell: String,
    /// Default scrollback line count applied to every pane unless overridden.
    /// Mapped from either the flat `scrollback = N` (back-compat) or the new
    /// `[scrollback] default_lines = N` (SPEC 02).
    pub scrollback: usize,
    /// Hard ceiling enforced when applying per-pane overrides or runtime
    /// `set-scrollback` requests. Defaults to 100_000.
    pub scrollback_max_lines: usize,
    /// Estimated-bytes threshold above which the daemon emits a one-shot
    /// per-pane warning. Defaults to 50 MiB. Hint, not a hard cap.
    pub scrollback_warn_bytes: usize,
    pub show_status_bar: bool,
    pub show_tab_bar: bool,
    /// Prefix key character (default: 'b' for Ctrl+B).
    pub prefix_key: char,
    /// Whether to persist pane scrollback into auto-saved snapshots.
    /// Off by default (snapshots stay small); enable to restore terminal
    /// contents on reattach. May be overridden per-project via `.ezpn.toml`'s
    /// `[workspace] persist_scrollback`.
    pub persist_scrollback: bool,
    /// Theme name (resolved against `~/.config/ezpn/themes/<name>.toml`
    /// then the embedded built-in palettes).  Defaults to `"default"`.
    pub theme: String,
    /// SPEC 08 hooks. Loaded from `[[hooks]]` blocks via the real `toml`
    /// crate (the legacy hand-rolled parser cannot handle TOML arrays).
    /// Empty vec when no hooks block is present.
    pub hooks: Vec<HookDef>,
}

impl Default for EzpnConfig {
    fn default() -> Self {
        Self {
            border: BorderStyle::Rounded,
            shell: std::env::var("SHELL").unwrap_or_else(|_| "/bin/sh".into()),
            scrollback: 10_000,
            scrollback_max_lines: 100_000,
            scrollback_warn_bytes: 50 * 1024 * 1024,
            show_status_bar: true,
            show_tab_bar: true,
            prefix_key: 'b',
            persist_scrollback: false,
            theme: "default".to_string(),
            hooks: Vec::new(),
        }
    }
}

/// Helper — `toml`-deserialize just the `[[hooks]]` blocks out of a
/// config file. Anything unknown to this view is silently ignored, so it
/// coexists with the legacy hand-rolled key=value parser.
#[derive(serde::Deserialize, Default)]
struct HooksOnlyView {
    #[serde(default)]
    hooks: Vec<HookDef>,
}

/// Parse SPEC 08 `[[hooks]]` blocks from a config file's full text,
/// validate each, and drop invalid entries with a warn line. Returns
/// only the well-formed hooks so daemon startup never aborts on a bad
/// hook definition (matches the existing tolerance for malformed
/// optional sections).
pub fn parse_hooks_section(contents: &str) -> Vec<HookDef> {
    let view: HooksOnlyView = match toml::from_str(contents) {
        Ok(v) => v,
        Err(e) => {
            eprintln!("ezpn: hooks parse failed, ignoring: {e}");
            return Vec::new();
        }
    };
    let mut out = Vec::with_capacity(view.hooks.len());
    for (i, def) in view.hooks.into_iter().enumerate() {
        match crate::daemon::hooks::validate(&def, i) {
            Ok(()) => out.push(def),
            Err(e) => eprintln!("ezpn: {e}; skipping"),
        }
    }
    out
}

/// Load config from ~/.config/ezpn/config.toml (simple key=value, no toml dep).
/// Format:
///   border = rounded
///   shell = /bin/zsh
///   scrollback = 10000
///   status_bar = true
///   tab_bar = true
///   theme = tokyo-night
///
/// `[ui]` section headers are accepted but ignored — every key is global.
pub fn load_config() -> EzpnConfig {
    let mut config = EzpnConfig::default();
    if let Some(path) = existing_config_path() {
        if let Ok(contents) = std::fs::read_to_string(&path) {
            parse_config_into(&contents, &mut config);
            // SPEC 08: parse the `[[hooks]]` array via the real toml crate;
            // the hand-rolled parser above can't handle TOML tables/arrays.
            config.hooks = parse_hooks_section(&contents);
        }
    }
    config
}

fn parse_config_into(contents: &str, config: &mut EzpnConfig) {
    // Section state: `Some("scrollback")` while inside `[scrollback]`, etc.
    // Other section names (e.g. `[ui]`) are accepted but their keys are still
    // routed through the global key table — preserves legacy behaviour where
    // `[ui]\ntheme = "..."` worked.
    let mut section: Option<String> = None;
    for line in contents.lines() {
        let line = line.trim();
        if line.is_empty() || line.starts_with('#') {
            continue;
        }
        if let Some(name) = line.strip_prefix('[').and_then(|s| s.strip_suffix(']')) {
            section = Some(name.trim().to_string());
            continue;
        }
        let Some((key, value)) = line.split_once('=') else {
            continue;
        };
        let key = key.trim();
        let value = normalize_value(value);

        // `[scrollback]` table — per SPEC 02. Keys here populate the new
        // EzpnConfig fields; values are capped against `scrollback_max_lines`
        // when applied, not here, so users can lower the cap at runtime.
        if section.as_deref() == Some("scrollback") {
            match key {
                "default_lines" => {
                    if let Ok(n) = value.parse::<usize>() {
                        config.scrollback = n;
                    }
                }
                "max_lines" => {
                    if let Ok(n) = value.parse::<usize>() {
                        config.scrollback_max_lines = n;
                    }
                }
                "warn_bytes" => {
                    if let Ok(n) = value.parse::<usize>() {
                        config.scrollback_warn_bytes = n;
                    }
                }
                _ => {}
            }
            continue;
        }

        match key {
            "border" => {
                if let Some(style) = BorderStyle::from_str(value) {
                    config.border = style;
                }
            }
            "shell" => config.shell = value.to_string(),
            "scrollback" => {
                // Flat key — keep back-compat. Users mixing `scrollback = N`
                // with `[scrollback] default_lines = M` get last-write-wins.
                if let Ok(n) = value.parse::<usize>() {
                    config.scrollback = n;
                }
            }
            "status_bar" => config.show_status_bar = value == "true",
            "tab_bar" => config.show_tab_bar = value == "true",
            "persist_scrollback" => {
                config.persist_scrollback = value == "true";
            }
            "prefix" => {
                let ch = value.to_lowercase();
                if let Some(c) = ch.chars().next() {
                    if c.is_ascii_lowercase() {
                        config.prefix_key = c;
                    }
                }
            }
            "theme" if !value.is_empty() => {
                config.theme = value.to_string();
            }
            _ => {} // ignore unknown keys
        }
    }

    // Apply max-lines cap to whichever default value won. Do this once at the
    // end so the `[scrollback] max_lines` key can lower the effective default
    // even when listed after `default_lines`.
    if config.scrollback > config.scrollback_max_lines {
        config.scrollback = config.scrollback_max_lines;
    }
}

fn normalize_value(value: &str) -> &str {
    let value = value.trim();
    if value.len() >= 2 {
        let first = value.as_bytes()[0];
        let last = value.as_bytes()[value.len() - 1];
        if (first == b'"' && last == b'"') || (first == b'\'' && last == b'\'') {
            return &value[1..value.len() - 1];
        }
    }
    value
}

/// Resolve the config file path, regardless of whether it currently exists.
/// Used for both reads and writes.
pub fn config_path() -> anyhow::Result<PathBuf> {
    let dir = std::env::var("XDG_CONFIG_HOME")
        .map(PathBuf::from)
        .unwrap_or_else(|_| {
            let mut home = dirs_fallback();
            home.push(".config");
            home
        });
    Ok(dir.join("ezpn").join("config.toml"))
}

/// Convenience for callers that only care about an *existing* config.
pub fn existing_config_path() -> Option<PathBuf> {
    let p = config_path().ok()?;
    if p.exists() {
        Some(p)
    } else {
        None
    }
}

/// User-friendly display path for the config file (with leading "~/" when
/// inside $HOME). Used by the settings panel header to show users where
/// their changes are saved.
pub fn display_config_path() -> String {
    let path = match config_path() {
        Ok(p) => p,
        Err(_) => return "~/.config/ezpn/config.toml".to_string(),
    };
    if let Ok(home) = std::env::var("HOME") {
        if let Ok(stripped) = path.strip_prefix(&home) {
            return format!("~/{}", stripped.display());
        }
    }
    path.display().to_string()
}

fn dirs_fallback() -> PathBuf {
    std::env::var("HOME")
        .map(PathBuf::from)
        .unwrap_or_else(|_| PathBuf::from("/tmp"))
}

/// Serialize the live settings panel state to the same key=value format
/// `load_config` understands. Only the knobs the panel can change are
/// emitted; other keys (shell, scrollback, prefix) are not present here
/// since the panel does not expose them.
fn serialize_settings(s: &Settings) -> String {
    let border = match s.border_style {
        BorderStyle::Single => "single",
        BorderStyle::Rounded => "rounded",
        BorderStyle::Heavy => "heavy",
        BorderStyle::Double => "double",
        BorderStyle::None => "none",
    };
    let mut out = String::new();
    out.push_str("# Written by ezpn settings panel.\n");
    out.push_str("# Edit by hand or via Ctrl+B Shift+, — reload with Ctrl+B r.\n");
    out.push_str(&format!("border = {border}\n"));
    out.push_str(&format!("status_bar = {}\n", s.show_status_bar));
    out.push_str(&format!("tab_bar = {}\n", s.show_tab_bar));
    out
}

/// Persist settings panel state to `~/.config/ezpn/config.toml` using an
/// atomic write (tmp file + rename). Creates the parent directory if it
/// doesn't exist. The temp filename includes the current pid so concurrent
/// daemons don't clobber each other's tmp files.
pub fn save_settings(s: &Settings) -> anyhow::Result<()> {
    let path = config_path()?;
    if let Some(dir) = path.parent() {
        std::fs::create_dir_all(dir)?;
    }
    let pid = std::process::id();
    let tmp_name = format!(
        "{}.tmp.{pid}",
        path.file_name()
            .map(|n| n.to_string_lossy().into_owned())
            .unwrap_or_else(|| "config.toml".to_string())
    );
    let tmp = path.with_file_name(tmp_name);
    let contents = serialize_settings(s);
    if let Err(e) = std::fs::write(&tmp, contents) {
        // Best-effort cleanup; rename never happened.
        let _ = std::fs::remove_file(&tmp);
        return Err(e.into());
    }
    if let Err(e) = std::fs::rename(&tmp, &path) {
        let _ = std::fs::remove_file(&tmp);
        return Err(e.into());
    }
    Ok(())
}

/// Apply file-loaded config knobs to a live `Settings` value. Only the
/// fields the settings panel manages are touched.
pub fn apply_config_to_settings(cfg: &EzpnConfig, s: &mut Settings) {
    s.border_style = cfg.border;
    s.show_status_bar = cfg.show_status_bar;
    s.show_tab_bar = cfg.show_tab_bar;
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::render::BorderStyle;
    use crate::settings::Settings;
    use std::sync::Mutex;

    /// Serializes tests that mutate the `XDG_CONFIG_HOME` env var so they
    /// don't race when cargo runs them in parallel within the same process.
    static ENV_LOCK: Mutex<()> = Mutex::new(());

    #[test]
    fn normalize_value_trims_quotes() {
        assert_eq!(normalize_value("rounded"), "rounded");
        assert_eq!(normalize_value(" \"rounded\" "), "rounded");
        assert_eq!(normalize_value(" '/bin/zsh' "), "/bin/zsh");
    }

    #[test]
    fn save_then_parse_roundtrips_panel_state() {
        let mut s = Settings::new(BorderStyle::Heavy);
        s.show_status_bar = false;
        s.show_tab_bar = true;

        let serialized = serialize_settings(&s);
        let mut cfg = EzpnConfig::default();
        parse_config_into(&serialized, &mut cfg);

        assert_eq!(cfg.border, BorderStyle::Heavy);
        assert!(!cfg.show_status_bar);
        assert!(cfg.show_tab_bar);
    }

    #[test]
    fn save_settings_writes_atomically_and_leaves_no_tmp() {
        let _guard = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
        let tmpdir = tempfile::tempdir().expect("tempdir");
        // Point XDG_CONFIG_HOME at our scratch dir for the duration of this test.
        let prev = std::env::var("XDG_CONFIG_HOME").ok();
        std::env::set_var("XDG_CONFIG_HOME", tmpdir.path());

        let mut s = Settings::new(BorderStyle::Double);
        s.show_status_bar = true;
        s.show_tab_bar = false;

        save_settings(&s).expect("save should succeed");

        let path = tmpdir.path().join("ezpn").join("config.toml");
        assert!(path.exists(), "config.toml should exist after save");

        // No leftover *.tmp.* siblings.
        let dir = path.parent().unwrap();
        let leftovers: Vec<_> = std::fs::read_dir(dir)
            .expect("read_dir")
            .flatten()
            .filter(|e| e.file_name().to_string_lossy().contains("config.toml.tmp."))
            .collect();
        assert!(
            leftovers.is_empty(),
            "expected no .tmp.* files, found {leftovers:?}"
        );

        // Round-trip via the public loader.
        let loaded = std::fs::read_to_string(&path).expect("read");
        let mut cfg = EzpnConfig::default();
        parse_config_into(&loaded, &mut cfg);
        assert_eq!(cfg.border, BorderStyle::Double);
        assert!(cfg.show_status_bar);
        assert!(!cfg.show_tab_bar);

        // Restore env.
        match prev {
            Some(v) => std::env::set_var("XDG_CONFIG_HOME", v),
            None => std::env::remove_var("XDG_CONFIG_HOME"),
        }
    }

    #[test]
    fn parse_hooks_section_round_trip() {
        let toml_src = r#"
[[hooks]]
event = "pane-died"
command = "notify-send 'pane died'"
shell = true
timeout_ms = 2000

[[hooks]]
event = "client-attached"
command = ["echo", "hi"]
"#;
        let hooks = parse_hooks_section(toml_src);
        assert_eq!(hooks.len(), 2);
        assert_eq!(hooks[0].event, crate::daemon::hooks::HookEvent::PaneDied);
        assert!(hooks[0].shell);
        assert_eq!(hooks[0].timeout_ms, 2000);
        assert_eq!(
            hooks[1].event,
            crate::daemon::hooks::HookEvent::ClientAttached
        );
        // Default timeout when omitted.
        assert_eq!(
            hooks[1].timeout_ms,
            crate::daemon::hooks::HOOK_DEFAULT_TIMEOUT_MS
        );
    }

    #[test]
    fn parse_hooks_section_drops_invalid_entries() {
        // Entry 0 is valid; entry 1 has out-of-range timeout; entry 2 has
        // shell metachars without shell=true. Loader should keep entry 0
        // and drop the rest with warn lines.
        let toml_src = r#"
[[hooks]]
event = "pane-died"
command = ["true"]

[[hooks]]
event = "pane-exited"
command = ["true"]
timeout_ms = 999999

[[hooks]]
event = "tab-created"
command = "echo hi | tee out"
shell = false
"#;
        let hooks = parse_hooks_section(toml_src);
        assert_eq!(hooks.len(), 1, "only the first valid hook should survive");
        assert_eq!(hooks[0].event, crate::daemon::hooks::HookEvent::PaneDied);
    }

    #[test]
    fn parse_hooks_section_empty_when_no_blocks() {
        let hooks = parse_hooks_section("shell = \"/bin/zsh\"\nscrollback = 1000\n");
        assert!(hooks.is_empty());
    }

    #[test]
    fn flat_scrollback_back_compat() {
        let mut cfg = EzpnConfig::default();
        parse_config_into("scrollback = 7777\n", &mut cfg);
        assert_eq!(cfg.scrollback, 7777);
        assert_eq!(cfg.scrollback_max_lines, 100_000);
    }

    #[test]
    fn scrollback_section_parses_all_keys() {
        let mut cfg = EzpnConfig::default();
        parse_config_into(
            "[scrollback]\n\
             default_lines = 5000\n\
             max_lines = 50000\n\
             warn_bytes = 1048576\n",
            &mut cfg,
        );
        assert_eq!(cfg.scrollback, 5000);
        assert_eq!(cfg.scrollback_max_lines, 50_000);
        assert_eq!(cfg.scrollback_warn_bytes, 1_048_576);
    }

    #[test]
    fn scrollback_section_caps_default_above_max() {
        // default_lines 200_000 with max_lines 100_000 should clamp to 100_000.
        let mut cfg = EzpnConfig::default();
        parse_config_into(
            "[scrollback]\ndefault_lines = 200000\nmax_lines = 100000\n",
            &mut cfg,
        );
        assert_eq!(cfg.scrollback, 100_000);
        assert_eq!(cfg.scrollback_max_lines, 100_000);
    }

    #[test]
    fn unknown_section_does_not_swallow_global_keys() {
        // Legacy `[ui]` header followed by a global key should still parse.
        let mut cfg = EzpnConfig::default();
        parse_config_into("[ui]\nshell = /bin/zsh\n", &mut cfg);
        assert_eq!(cfg.shell, "/bin/zsh");
    }

    #[test]
    fn save_settings_creates_missing_parent_dir() {
        let _guard = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
        let tmpdir = tempfile::tempdir().expect("tempdir");
        let prev = std::env::var("XDG_CONFIG_HOME").ok();
        std::env::set_var("XDG_CONFIG_HOME", tmpdir.path().join("does-not-exist-yet"));

        let s = Settings::new(BorderStyle::Single);
        save_settings(&s).expect("save should create parent dir");

        let path = tmpdir
            .path()
            .join("does-not-exist-yet")
            .join("ezpn")
            .join("config.toml");
        assert!(path.exists());

        match prev {
            Some(v) => std::env::set_var("XDG_CONFIG_HOME", v),
            None => std::env::remove_var("XDG_CONFIG_HOME"),
        }
    }
}