grit_lib/config/

core.rs

//! Git-compatible configuration file parser and accessor.
//!
//! Supports the standard Git config file format:
//!
//! ```text
//! [section]
//!     key = value
//! [section "subsection"]
//!     key = value
//! ```
//!
//! # Multi-file layering
//!
//! Git reads configuration from several files in priority order:
//!
//! 1. System (`/etc/gitconfig`)
//! 2. Global (`~/.gitconfig` or `$XDG_CONFIG_HOME/git/config`)
//! 3. Local (`.git/config`)
//! 4. Worktree (`.git/config.worktree`)
//! 5. Command-line (`-c key=value` or `GIT_CONFIG_*`)
//!
//! [`ConfigSet`] merges all layers; last-wins for single-valued keys.
//!
//! # Include directives
//!
//! `[include] path = <path>` and `[includeIf "<condition>"] path = <path>`
//! are supported. Conditions: `gitdir:`, `gitdir/i:`, `onbranch:`,
//! and `hasconfig:remote.*.url:`.
//!
//! An included file is merged in place, at the position of its directive, so
//! later entries still override it. `hasconfig:remote.*.url:<glob>` matches
//! against every `remote.<name>.url` value of the whole load, not just the
//! files read so far: a global include can select a work identity from a
//! remote defined in the repository `config`. As in Git, remote URLs may not
//! be set in a file reached through a conditional include once such a
//! condition is evaluated ([`ConfigError::RemoteUrlInHasconfigInclude`]).

use crate::git_path::CanonicalizeExt;
use std::borrow::Cow;
use std::collections::HashMap;

use crate::environment::Environment;
use std::fmt;
use std::fs;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::time::SystemTime;

use crate::error::{
    BadNumericSource, ConfigError, ConfigValueError, Error, InvalidKeyReason, Result,
};

/// Test-only counters for config cascade load activity (see `porcelain_ops_load_config_cascade_once`).
#[cfg(test)]
pub mod cascade_load_counters {
    use std::cell::Cell;

    // Counters are per thread like `MEASURING`, so tests measuring on parallel threads do not
    // add to or reset each other's counts.
    thread_local! {
        static MEASURING: Cell<bool> = const { Cell::new(false) };
        static UNCACHED: Cell<usize> = const { Cell::new(0) };
        static CACHE_VALIDATED: Cell<usize> = const { Cell::new(0) };
    }

    /// Run `f` while recording cascade loads on this thread only (parallel-safe).
    pub fn measure<R>(f: impl FnOnce() -> R) -> R {
        MEASURING.with(|m| {
            m.set(true);
            reset();
            let out = f();
            m.set(false);
            out
        })
    }

    /// Reset counters before an operation under test.
    pub fn reset() {
        UNCACHED.with(|c| c.set(0));
        CACHE_VALIDATED.with(|c| c.set(0));
    }

    /// Full cascade parses (cache miss).
    #[must_use]
    pub fn uncached_loads() -> usize {
        UNCACHED.with(Cell::get)
    }

    /// Served from the process-global config cache after stat revalidation.
    #[must_use]
    pub fn cache_validated_loads() -> usize {
        CACHE_VALIDATED.with(Cell::get)
    }

    /// Total [`ConfigSet::load`] / [`ConfigSet::load_with_options`] invocations.
    #[must_use]
    pub fn total_loads() -> usize {
        uncached_loads().saturating_add(cache_validated_loads())
    }

    pub(crate) fn record_uncached() {
        if MEASURING.with(Cell::get) {
            UNCACHED.with(|c| c.set(c.get() + 1));
        }
    }
}
use crate::refs;
use crate::wildmatch::{wildmatch, WM_CASEFOLD, WM_PATHNAME};

/// The scope (origin) of a configuration value.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum ConfigScope {
    /// System-wide configuration (`/etc/gitconfig`).
    System,
    /// Per-user global configuration (`~/.gitconfig` or XDG).
    Global,
    /// Repository-local configuration (`.git/config`).
    Local,
    /// Per-worktree configuration (`.git/config.worktree`).
    Worktree,
    /// Command-line overrides (`-c key=value`).
    Command,
}

impl fmt::Display for ConfigScope {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::System => write!(f, "system"),
            Self::Global => write!(f, "global"),
            Self::Local => write!(f, "local"),
            Self::Worktree => write!(f, "worktree"),
            Self::Command => write!(f, "command"),
        }
    }
}

/// Origin metadata for the winning config value of a key.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ConfigValueOrigin {
    /// String value, or `"true"` for a bare boolean key. Only `None` when the key is missing
    /// (this struct is not used for missing keys — see [`ConfigSet::get_with_origin`]).
    pub value: Option<String>,
    /// Config layer that supplied the value.
    pub scope: ConfigScope,
    /// Source file when file-backed; absent for command-line overrides.
    pub file: Option<PathBuf>,
    /// One-based line number in `file`; `None` for command-line / `-f` scope (Git has no file line).
    pub line: Option<usize>,
}

/// A single configuration entry with its origin metadata.
#[derive(Debug, Clone)]
pub struct ConfigEntry {
    /// Fully-qualified key in canonical form: `section.subsection.name`
    /// (section and name lowercased; subsection preserves case).
    pub key: String,
    /// The raw string value, or `None` for a boolean-true bare key.
    pub value: Option<String>,
    /// Which scope this entry came from.
    pub scope: ConfigScope,
    /// The file this entry was read from (if file-backed).
    pub file: Option<PathBuf>,
    /// One-based line number in the source file.
    pub line: usize,
}

/// Where a [`ConfigFile`] was loaded from for Git include semantics.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ConfigIncludeOrigin {
    /// Normal path on disk (`-f`, global/local config files, etc.).
    Disk,
    /// `--file -` (stdin).
    Stdin,
    /// Synthetic file built from `GIT_CONFIG_PARAMETERS` / `git -c`.
    CommandLine,
    /// `git config --blob=…`.
    Blob,
}

/// A parsed configuration file that preserves the raw text for round-trip
/// editing (set/unset/rename-section/remove-section).
#[derive(Debug, Clone)]
pub struct ConfigFile {
    /// The path to this config file on disk.
    pub path: PathBuf,
    /// The scope this file represents.
    pub scope: ConfigScope,
    /// Parsed entries (in file order).
    pub entries: Vec<ConfigEntry>,
    /// Raw lines of the file (for round-trip editing).
    raw_lines: Vec<String>,
    /// Source kind for `[include]` resolution (Git `CONFIG_ORIGIN_*`).
    pub include_origin: ConfigIncludeOrigin,
}

/// A merged view across all configuration scopes.
///
/// Entries are stored in file-order within each scope; scopes are layered
/// in priority order (system < global < local < worktree < command).
///
/// # Examples
///
/// ```
/// use grit_lib::repo::{InitOptions, Repository};
///
/// # fn main() -> grit_lib::error::Result<()> {
/// let dir = tempfile::tempdir()?;
/// let repo = Repository::init(dir.path(), &InitOptions::default())?;
/// let cfg = repo.config()?;
/// assert!(cfg.get("core.repositoryformatversion").is_some());
/// # Ok(())
/// # }
/// ```
#[derive(Debug, Clone, Default)]
pub struct ConfigSet {
    /// All entries across all scopes, in load order.
    entries: Vec<ConfigEntry>,
}

/// Context for evaluating `[includeIf]` conditions (`gitdir:`, `onbranch:`, `hasconfig:`).
#[derive(Debug, Clone)]
pub struct IncludeContext {
    /// Git directory path used for `gitdir:` matching (may contain unresolved symlinks).
    pub git_dir: Option<PathBuf>,
    /// When true, `git -c include.path=relative` fails instead of ignoring the include.
    pub command_line_relative_include_is_error: bool,
    /// Working directory for relative include resolution (from [`Environment::cwd`]).
    pub cwd: PathBuf,
    /// Symlink-preserving `$PWD` for `gitdir:` matching when set.
    pub pwd: Option<String>,
    /// Environment used for `~/` expansion in include paths.
    pub env: std::sync::Arc<Environment>,
}

impl Default for IncludeContext {
    fn default() -> Self {
        Self {
            git_dir: None,
            command_line_relative_include_is_error: false,
            cwd: PathBuf::from("."),
            pwd: None,
            env: std::sync::Arc::new(Environment::empty()),
        }
    }
}

/// Options controlling how [`ConfigSet::load_with_options`] merges files and includes.
#[derive(Clone)]
pub struct LoadConfigOptions {
    /// Load `/etc/gitconfig` (unless `GIT_CONFIG_NOSYSTEM` is enabled).
    pub include_system: bool,
    /// Expand `[include]` / `[includeIf]` while reading file-backed layers.
    pub process_includes: bool,
    /// Expand includes for synthetic command-line config built from `GIT_CONFIG_PARAMETERS`.
    pub command_includes: bool,
    /// Git directory and environment used to evaluate `[includeIf]` conditions.
    pub include_ctx: IncludeContext,
    /// Optional sink for non-fatal config load warnings.
    pub diagnostics: Option<crate::diagnostics::DiagnosticsHandle>,
    /// When set, repository-local `config` is read at most once per [`crate::repo_caches::RepoCaches`] handle.
    pub repo_caches: Option<std::sync::Arc<crate::repo_caches::RepoCaches>>,
}

impl std::fmt::Debug for LoadConfigOptions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("LoadConfigOptions")
            .field("include_system", &self.include_system)
            .field("process_includes", &self.process_includes)
            .field("command_includes", &self.command_includes)
            .field("include_ctx", &self.include_ctx)
            .finish_non_exhaustive()
    }
}

impl Default for LoadConfigOptions {
    fn default() -> Self {
        Self {
            include_system: true,
            process_includes: true,
            command_includes: true,
            include_ctx: IncludeContext::default(),
            diagnostics: None,
            repo_caches: None,
        }
    }
}

impl LoadConfigOptions {
    /// Options for the full cascade of the repository at `git_dir`, as its
    /// [`crate::repo::Repository`] handle loads it: system config included, `gitdir:`
    /// conditions matched against `git_dir`, and the local `config` read through `repo_caches`.
    ///
    /// Every loader of one repository's cascade must use these options so they share a single
    /// [`crate::repo_caches::RepoCaches`] cache entry instead of parsing the files again.
    pub(crate) fn for_repository(
        env: &Environment,
        git_dir: Option<&Path>,
        repo_caches: Option<Arc<crate::repo_caches::RepoCaches>>,
    ) -> Self {
        Self {
            include_ctx: IncludeContext {
                git_dir: git_dir.map(Path::to_path_buf),
                cwd: env.cwd.clone(),
                pwd: env.pwd.clone(),
                ..IncludeContext::default()
            },
            repo_caches,
            ..Self::default()
        }
    }
}

/// Source file for `--show-origin` style output.
///
/// `-f` / `--file` reads use `command` scope but keep a real file path; synthetic
/// `GIT_CONFIG_PARAMETERS` / `-c` entries have no file.
#[must_use]
pub fn config_entry_origin_file(entry: &ConfigEntry) -> Option<&Path> {
    if entry.scope == ConfigScope::Command && entry.file.is_none() {
        None
    } else {
        entry.file.as_deref()
    }
}

/// One-based source line for `--show-origin` output, when applicable.
#[must_use]
pub fn config_entry_origin_line(entry: &ConfigEntry) -> Option<usize> {
    if entry.scope == ConfigScope::Command && entry.file.is_none() {
        None
    } else {
        (entry.line > 0).then_some(entry.line)
    }
}

// ── Canonical key helpers ────────────────────────────────────────────

/// Normalise a config key to canonical form.
///
/// - Section name is lowercased.
/// - Variable name (last dot-separated component) is lowercased.
/// - Subsection (middle components) preserves original case.
///
/// Returns `Err` if the key has fewer than two dot-separated parts.
///
/// # Examples
///
/// - `core.bare` → `core.bare`
/// - `Section.SubSection.Key` → `section.SubSection.key`
/// - `CORE.BARE` → `core.bare`
pub fn canonical_key(raw: &str) -> Result<String> {
    let invalid = |reason| {
        Error::Config(ConfigError::InvalidKey {
            key: raw.to_owned(),
            reason,
        })
    };
    if raw.contains('\n') || raw.contains('\r') {
        return Err(invalid(InvalidKeyReason::LineBreak));
    }

    let (Some(first_dot), Some(last_dot)) = (raw.find('.'), raw.rfind('.')) else {
        return Err(invalid(InvalidKeyReason::MissingSection));
    };

    if last_dot == raw.len() - 1 {
        return Err(invalid(InvalidKeyReason::MissingVariable));
    }

    let section = &raw[..first_dot];
    let name = &raw[last_dot + 1..];

    // Validate section name: must be alphanumeric or hyphen
    if section.is_empty() || !section.chars().all(|c| c.is_alphanumeric() || c == '-') {
        return Err(invalid(InvalidKeyReason::InvalidSection));
    }

    // Validate variable name: must start with alpha, rest alphanumeric or hyphen
    if !name.chars().next().is_some_and(|c| c.is_ascii_alphabetic())
        || !name.chars().all(|c| c.is_alphanumeric() || c == '-')
    {
        return Err(invalid(InvalidKeyReason::InvalidVariable));
    }

    let mut key = String::with_capacity(raw.len());
    push_lowercase(&mut key, section);
    key.push('.');
    if first_dot != last_dot {
        key.push_str(&raw[first_dot + 1..last_dot]);
        key.push('.');
    }
    push_lowercase(&mut key, name);
    Ok(key)
}

/// Append `s` lowercased like [`str::to_lowercase`], without a temporary for ASCII input.
fn push_lowercase(out: &mut String, s: &str) {
    if s.is_ascii() {
        out.extend(s.bytes().map(|b| char::from(b.to_ascii_lowercase())));
    } else {
        out.push_str(&s.to_lowercase());
    }
}

// ── Parser ──────────────────────────────────────────────────────────

/// Display path for config diagnostics (matches the internal `config_error_path_display` helper for public callers).
#[must_use]
pub fn config_file_display_for_error(path: &Path) -> String {
    config_error_path_display(path)
}

fn config_error_path_display(path: &Path) -> String {
    if path == Path::new("-") {
        return "standard input".to_owned();
    }
    if path.file_name().and_then(|s| s.to_str()) == Some("config")
        && path
            .parent()
            .and_then(|p| p.file_name())
            .and_then(|s| s.to_str())
            == Some(".git")
    {
        return ".git/config".to_owned();
    }
    path.display().to_string()
}

/// `fetch.negotiationAlgorithm` written without `= value` is rejected at parse time.
fn reject_valueless_negotiation_algorithm(
    key: &str,
    value: Option<&str>,
    path: &Path,
    line: usize,
) -> Result<()> {
    if key != "fetch.negotiationalgorithm" || value.is_some() {
        return Ok(());
    }
    Err(ConfigError::BadConfigVariable {
        key: key.to_owned(),
        file: config_error_path_display(path),
        line,
    }
    .into())
}

/// State tracked while parsing a config file line-by-line.
struct Parser {
    section: String,
    subsection: Option<String>,
    /// `section.` or `section.subsection.` in canonical case, shared by every key of the
    /// current section.
    key_prefix: String,
}

impl Parser {
    fn new() -> Self {
        Self {
            section: String::new(),
            subsection: None,
            key_prefix: String::new(),
        }
    }

    fn valid_variable_name(name: &str) -> bool {
        let name = name.trim();
        name.as_bytes().first().is_some_and(u8::is_ascii_alphabetic)
            && name.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-')
    }

    fn set_section(&mut self, section: String, subsection: Option<String>) {
        self.key_prefix.clear();
        push_lowercase(&mut self.key_prefix, &section);
        self.key_prefix.push('.');
        if let Some(sub) = &subsection {
            self.key_prefix.push_str(sub);
            self.key_prefix.push('.');
        }
        self.section = section;
        self.subsection = subsection;
    }

    /// Build the canonical key for a variable name in the current section.
    ///
    /// `name` must already satisfy [`Self::valid_variable_name`], so it is ASCII.
    fn make_key(&self, name: &str) -> String {
        let mut key = String::with_capacity(self.key_prefix.len() + name.len());
        key.push_str(&self.key_prefix);
        push_lowercase(&mut key, name);
        key
    }

    /// Parse a section header line like `[section]` or `[section "subsection"]`.
    ///
    /// Returns `true` if the line was a section header.
    /// If there is content after `]` (an inline key=value), it is returned
    /// via the `inline_remainder` parameter.
    fn try_parse_section_with_remainder<'a>(
        &mut self,
        line: &'a str,
        inline_remainder: &mut Option<&'a str>,
    ) -> bool {
        let trimmed = line.trim();
        if !trimmed.starts_with('[') {
            return false;
        }
        // Find the closing `]` — but for subsection headers like
        // [section "sub\"escaped"], we need to skip escaped chars
        // inside quotes.
        let end = {
            let bytes = trimmed.as_bytes();
            let mut i = 1; // skip opening '['
            let mut in_quotes = false;
            let mut found = None;
            while i < bytes.len() {
                if in_quotes {
                    if bytes[i] == b'\\' {
                        i += 2; // skip escaped char
                        continue;
                    }
                    if bytes[i] == b'"' {
                        in_quotes = false;
                    }
                } else {
                    if bytes[i] == b'"' {
                        in_quotes = true;
                    }
                    if bytes[i] == b']' {
                        found = Some(i);
                        break;
                    }
                }
                i += 1;
            }
            match found {
                Some(i) => i,
                None => return false,
            }
        };
        let inside = &trimmed[1..end];
        // Check for subsection: [section "subsection"]
        if let Some(quote_start) = inside.find('"') {
            let section = inside[..quote_start].trim().to_owned();
            let rest = &inside[quote_start + 1..];
            // Find unescaped closing quote
            let mut sub = String::new();
            let mut chars = rest.chars();
            while let Some(ch) = chars.next() {
                if ch == '\\' {
                    if let Some(escaped) = chars.next() {
                        sub.push(escaped);
                    }
                } else if ch == '"' {
                    break;
                } else {
                    sub.push(ch);
                }
            }
            self.set_section(section, Some(sub));
        } else {
            self.set_section(inside.trim().to_owned(), None);
        }
        // Check for inline content after the closing `]`
        let after = trimmed[end + 1..].trim();
        if !after.is_empty() && !after.starts_with('#') && !after.starts_with(';') {
            *inline_remainder = Some(after);
        } else {
            *inline_remainder = None;
        }
        true
    }

    /// Parse a section header line (without inline remainder tracking).
    fn try_parse_section(&mut self, line: &str) -> bool {
        let mut _remainder = None;
        self.try_parse_section_with_remainder(line, &mut _remainder)
    }

    /// Parse a `key = value` or bare `key` line.
    ///
    /// Returns `Some((canonical_key, value))` if this is a variable line.
    fn try_parse_entry(&self, line: &str) -> Option<(String, Option<String>)> {
        let trimmed = line.trim();
        if trimmed.is_empty() || trimmed.starts_with('#') || trimmed.starts_with(';') {
            return None;
        }
        if trimmed.starts_with('[') {
            return None;
        }
        if self.section.is_empty() {
            return None;
        }

        if let Some(eq_pos) = trimmed.find('=') {
            let raw_name = trimmed[..eq_pos].trim();
            if !Self::valid_variable_name(raw_name) {
                return None;
            }
            let raw_value = trimmed[eq_pos + 1..].trim();
            // Strip inline comment (not inside quotes)
            let value = parse_config_value(strip_inline_comment(raw_value));
            let key = self.make_key(raw_name);
            Some((key, Some(value)))
        } else {
            // Bare key (boolean true)
            let raw_name = strip_inline_comment(trimmed);
            if raw_name.split_whitespace().count() > 1 {
                return None;
            }
            let raw_name = raw_name.trim();
            if !Self::valid_variable_name(raw_name) {
                return None;
            }
            let key = self.make_key(raw_name);
            Some((key, None))
        }
    }
}

/// Check if a value line ends with a continuation backslash.
///
/// This checks the value portion (after `=`) for a trailing `\` that is
/// outside quotes and outside an inline comment. If the `\` is after
/// a `#` or `;` that starts a comment, it does NOT count as continuation.
/// True when the value portion (after the first `=`) ends inside an unclosed double-quoted span.
///
/// Mirrors Git config continuation rules: a line ending with an open `"` continues on the next
/// physical line. Outside quotes, `#` / `;` start comments and the line is complete.
fn entry_line_value_has_unclosed_quote(line: &str) -> bool {
    let trimmed = line.trim();
    let Some(eq_pos) = trimmed.find('=') else {
        return false;
    };
    let raw_value = trimmed[eq_pos + 1..].trim_start();
    let mut in_quote = false;
    let mut last_was_backslash = false;
    // Every byte that matters is ASCII, and UTF-8 never reuses ASCII bytes inside a
    // multi-byte character, so scanning bytes gives the same answer as scanning chars.
    for b in raw_value.bytes() {
        match b {
            b'"' if !last_was_backslash => {
                in_quote = !in_quote;
                last_was_backslash = false;
            }
            b'\\' if !last_was_backslash => {
                last_was_backslash = true;
                continue;
            }
            b'#' | b';' if !in_quote && !last_was_backslash => return false,
            _ => {
                last_was_backslash = false;
            }
        }
    }
    in_quote
}

fn value_line_continues(line: &str) -> bool {
    let trimmed = line.trim();
    if trimmed.is_empty() || trimmed.starts_with('#') || trimmed.starts_with(';') {
        return false;
    }
    // Find the value portion (after '=')
    // If no '=', this is a bare key — no continuation
    let value_part = match trimmed.find('=') {
        Some(pos) => &trimmed[pos + 1..],
        None => return false,
    };
    // Walk the value portion tracking quotes and comments
    let mut in_quote = false;
    let mut last_was_backslash = false;
    let mut in_comment = false;
    for b in value_part.bytes() {
        if in_comment {
            // Inside comment, backslash doesn't matter
            last_was_backslash = false;
            continue;
        }
        match b {
            b'"' if !last_was_backslash => {
                in_quote = !in_quote;
                last_was_backslash = false;
            }
            b'\\' if !last_was_backslash => {
                last_was_backslash = true;
                continue;
            }
            b'#' | b';' if !in_quote && !last_was_backslash => {
                in_comment = true;
                last_was_backslash = false;
            }
            _ => {
                last_was_backslash = false;
            }
        }
    }
    // The line continues if it ends with an unescaped backslash outside comments
    last_was_backslash && !in_comment
}

/// Strip an inline comment (`#` or `;`) that is not inside quotes, and the whitespace
/// before it. The result is always a prefix of `s`.
fn strip_inline_comment(s: &str) -> &str {
    let bytes = s.as_bytes();
    let mut in_quote = false;
    let mut last_was_backslash = false;
    let mut i = 0;
    while i < bytes.len() {
        match bytes[i] {
            b'"' if !last_was_backslash => {
                in_quote = !in_quote;
                last_was_backslash = false;
            }
            b'\\' if !last_was_backslash => {
                last_was_backslash = true;
                if in_quote && i + 1 < bytes.len() {
                    i += 1;
                    last_was_backslash = false;
                }
            }
            b'#' | b';' if !in_quote && !last_was_backslash => break,
            _ => last_was_backslash = false,
        }
        i += 1;
    }
    // `i` stops on an ASCII byte or the end, so it is a char boundary.
    s[..i].trim_end()
}

/// Parse a config value after `=` (comments already stripped).
fn parse_config_value(s: &str) -> String {
    if s.starts_with('"') {
        unescape_value(s)
    } else {
        unescape_unquoted_value(s)
    }
}

/// Unquoted config values: backslash escapes; literal TAB characters are preserved to match
/// `git config --get` on Git **≥ 2.55** (older Git collapses literal tabs to spaces; see
/// `t1300_*` oracle gating in `grit-lib/tests/config_parse.rs`).
fn unescape_unquoted_value(s: &str) -> String {
    let mut result = String::with_capacity(s.len());
    let mut chars = s.chars();
    while let Some(ch) = chars.next() {
        if ch == '\\' {
            match chars.next() {
                Some('n') => result.push('\n'),
                Some('r') => result.push('\r'),
                Some('t') => result.push('\t'),
                Some('b') => result.push('\x08'),
                Some('\\') => result.push('\\'),
                Some('"') => result.push('"'),
                Some(other) => {
                    result.push('\\');
                    result.push(other);
                }
                None => result.push('\\'),
            }
        } else {
            result.push(ch);
        }
    }
    result
}

/// Unescape a quoted config value: handle `\"`, `\\`, `\n`, `\t`, `\b`, and strip
/// surrounding quotes.
fn unescape_value(s: &str) -> String {
    let mut result = String::with_capacity(s.len());
    let mut chars = s.chars();
    while let Some(ch) = chars.next() {
        match ch {
            '"' => { /* strip quotes */ }
            '\\' => match chars.next() {
                Some('n') => result.push('\n'),
                Some('r') => result.push('\r'),
                Some('t') => result.push('\t'),
                Some('b') => result.push('\x08'),
                Some('\\') => result.push('\\'),
                Some('"') => result.push('"'),
                Some(other) => {
                    result.push('\\');
                    result.push(other);
                }
                None => result.push('\\'),
            },
            _ => result.push(ch),
        }
    }
    result
}

/// Escape a config value for writing back to a file.
///
/// Wraps in double quotes if the value contains leading/trailing whitespace,
/// internal quotes, backslashes, or special characters.
/// Escape a subsection name for writing in a config section header.
/// In subsection names, `"` and `\` must be escaped.
fn escape_subsection(s: &str) -> String {
    let mut out = String::with_capacity(s.len());
    for ch in s.chars() {
        match ch {
            '"' => out.push_str("\\\""),
            '\\' => out.push_str("\\\\"),
            other => out.push(other),
        }
    }
    out
}

fn escape_value(s: &str) -> String {
    // Quote leading `-` so values are not mistaken for config options (Git does this for
    // submodule paths like `-sub` in `.gitmodules`), but leave signed numeric values bare.
    let leading_dash_needs_quoting = s.starts_with('-') && parse_i64(s).is_err();
    let must_quote = leading_dash_needs_quoting
        || s.starts_with(' ')
        || s.starts_with('\t')
        || s.ends_with(' ')
        || s.ends_with('\t')
        || s.contains('"')
        || s.contains('#')
        || s.contains(';');

    if must_quote {
        return escape_value_quoted(s);
    }

    if s.contains('\n') || s.contains('\r') || s.contains('\t') || s.contains('\\') {
        let mut out = String::with_capacity(s.len() + 4);
        for ch in s.chars() {
            match ch {
                '\n' => out.push_str("\\n"),
                '\r' => out.push_str("\\r"),
                '\t' => out.push_str("\\t"),
                '\\' => out.push_str("\\\\"),
                '"' => out.push_str("\\\""),
                other => out.push(other),
            }
        }
        return out;
    }

    s.to_owned()
}

/// Compile a Git config value-pattern (`drop`, `!keep`, or full regex).
fn compile_config_value_pattern(pat: &str) -> std::result::Result<(regex::Regex, bool), Error> {
    let (negated, actual_pat) = if let Some(rest) = pat.strip_prefix('!') {
        (true, rest)
    } else {
        (false, pat)
    };
    let re = regex::Regex::new(actual_pat).map_err(|e| {
        Error::Config(ConfigError::InvalidValuePattern {
            pattern: pat.to_owned(),
            reason: e.to_string(),
        })
    })?;
    Ok((re, negated))
}

fn value_matches_config_pattern(re: &regex::Regex, negated: bool, value: &str) -> bool {
    let matched = re.is_match(value);
    if negated {
        !matched
    } else {
        matched
    }
}

fn escape_value_quoted(s: &str) -> String {
    let mut out = String::with_capacity(s.len() + 4);
    out.push('"');
    for ch in s.chars() {
        match ch {
            '"' => out.push_str("\\\""),
            '\\' => out.push_str("\\\\"),
            '\n' => out.push_str("\\n"),
            '\r' => out.push_str("\\r"),
            '\t' => out.push_str("\\t"),
            other => out.push(other),
        }
    }
    out.push('"');
    out
}

/// Format a comment suffix for appending to a config value line.
///
/// Matches Git's `git_config_prepare_comment_string` normalization:
/// leading space/tab is preserved only when followed by `#`; otherwise ` # ` is inserted.
///
/// # Errors
///
/// Returns [`ConfigError::MultilineCommentNotAllowed`] when `comment` contains `\n` or `\r`.
fn format_comment_suffix(comment: Option<&str>) -> Result<String> {
    match comment {
        None => Ok(String::new()),
        Some(c) => {
            if c.contains('\n') || c.contains('\r') {
                return Err(Error::Config(ConfigError::MultilineCommentNotAllowed));
            }
            let leading_blanks = c.find(|ch| ch != ' ' && ch != '\t').unwrap_or(c.len());
            let after_blanks = &c[leading_blanks..];
            if leading_blanks > 0 && after_blanks.starts_with('#') {
                Ok(c.to_owned())
            } else if c.starts_with('#') {
                Ok(format!(" {c}"))
            } else {
                Ok(format!(" # {c}"))
            }
        }
    }
}

impl ConfigFile {
    /// Parse a config file from its raw text content.
    ///
    /// # Parameters
    ///
    /// - `path` — the file path (stored for diagnostics and round-trip writes).
    /// - `content` — the raw text of the file.
    /// - `scope` — the [`ConfigScope`] this file represents.
    ///
    /// # Errors
    ///
    /// Returns [`Error::Config`] on malformed input.
    pub fn parse(path: &Path, content: &str, scope: ConfigScope) -> Result<Self> {
        let content = content.strip_prefix('\u{feff}').unwrap_or(content);
        let raw_lines: Vec<String> = content
            .lines()
            .map(|l| l.strip_suffix('\r').unwrap_or(l))
            .map(String::from)
            .collect();
        let mut entries = Vec::new();
        let mut parser = Parser::new();

        let mut idx = 0;
        while idx < raw_lines.len() {
            let start_idx = idx;
            let line = &raw_lines[idx];
            idx += 1;

            // Pure comment lines don't continue even with trailing \
            let trimmed = line.trim();
            if trimmed.starts_with('#') || trimmed.starts_with(';') {
                continue;
            }

            let mut inline_remainder = None;
            if parser.try_parse_section_with_remainder(line, &mut inline_remainder) {
                // Check if there's an inline key=value after the section header
                if let Some(remainder) = inline_remainder {
                    if let Some((key, value)) = parser.try_parse_entry(remainder) {
                        reject_valueless_negotiation_algorithm(
                            &key,
                            value.as_deref(),
                            path,
                            start_idx + 1,
                        )?;
                        entries.push(ConfigEntry {
                            key,
                            value,
                            scope,
                            file: Some(path.to_path_buf()),
                            line: start_idx + 1,
                        });
                    }
                }
                continue;
            }

            // For entry lines, we need to check continuation.
            // Build a logical line by joining continuations.
            let mut logical_line = Cow::Borrowed(line.as_str());
            while value_line_continues(&logical_line) && idx < raw_lines.len() {
                // Remove the trailing backslash
                let t = logical_line.trim_end();
                let mut joined = t[..t.len() - 1].to_string();
                // Append next line (trimmed of leading whitespace)
                joined.push_str(raw_lines[idx].trim_start());
                logical_line = Cow::Owned(joined);
                idx += 1;
            }

            let mut unclosed_quote = entry_line_value_has_unclosed_quote(&logical_line);
            while unclosed_quote && idx < raw_lines.len() {
                let next = raw_lines[idx].trim_start();
                logical_line.to_mut().push_str(next);
                idx += 1;
                unclosed_quote = entry_line_value_has_unclosed_quote(&logical_line);
            }
            if unclosed_quote {
                let file_disp = config_error_path_display(path);
                return Err(ConfigError::BadConfigLineInFile {
                    file: file_disp,
                    line: start_idx + 1,
                }
                .into());
            }

            if let Some((key, value)) = parser.try_parse_entry(&logical_line) {
                reject_valueless_negotiation_algorithm(
                    &key,
                    value.as_deref(),
                    path,
                    start_idx + 1,
                )?;
                entries.push(ConfigEntry {
                    key,
                    value,
                    scope,
                    file: Some(path.to_path_buf()),
                    line: start_idx + 1,
                });
            } else if logical_line.trim().is_empty() {
                continue;
            } else {
                let file_disp = config_error_path_display(path);
                let location = if path == Path::new("-") {
                    file_disp
                } else {
                    format!("file {file_disp}")
                };
                return Err(ConfigError::BadConfigLine {
                    location,
                    line: start_idx + 1,
                }
                .into());
            }
        }

        Ok(Self {
            path: path.to_path_buf(),
            scope,
            entries,
            raw_lines,
            include_origin: ConfigIncludeOrigin::Disk,
        })
    }

    /// Like [`Self::parse`] for `.gitmodules`, but on an unclosed-quote / bad line returns entries
    /// parsed **before** that line plus the one-based line number of the bad logical line.
    ///
    /// Git streams config and still applies entries from valid preceding lines; submodule-config
    /// tests rely on that when a later `.gitmodules` line is malformed.
    pub fn parse_gitmodules_best_effort(
        path: &Path,
        content: &str,
        scope: ConfigScope,
    ) -> (Vec<ConfigEntry>, Option<usize>) {
        let raw_lines: Vec<String> = content
            .lines()
            .map(|l| l.strip_suffix('\r').unwrap_or(l))
            .map(String::from)
            .collect();
        let mut entries = Vec::new();
        let mut parser = Parser::new();

        let mut idx = 0;
        while idx < raw_lines.len() {
            let start_idx = idx;
            let line = &raw_lines[idx];
            idx += 1;

            let trimmed = line.trim();
            if trimmed.starts_with('#') || trimmed.starts_with(';') {
                continue;
            }

            let mut inline_remainder = None;
            if parser.try_parse_section_with_remainder(line, &mut inline_remainder) {
                if let Some(remainder) = inline_remainder {
                    if let Some((key, value)) = parser.try_parse_entry(remainder) {
                        entries.push(ConfigEntry {
                            key,
                            value,
                            scope,
                            file: Some(path.to_path_buf()),
                            line: start_idx + 1,
                        });
                    }
                }
                continue;
            }

            let mut logical_line = line.clone();
            while value_line_continues(&logical_line) && idx < raw_lines.len() {
                let t = logical_line.trim_end();
                logical_line = t[..t.len() - 1].to_string();
                let next = raw_lines[idx].trim_start();
                logical_line.push_str(next);
                idx += 1;
            }

            while entry_line_value_has_unclosed_quote(&logical_line) && idx < raw_lines.len() {
                let next = raw_lines[idx].trim_start();
                logical_line.push_str(next);
                idx += 1;
            }
            if entry_line_value_has_unclosed_quote(&logical_line) {
                return (entries, Some(start_idx + 1));
            }

            if let Some((key, value)) = parser.try_parse_entry(&logical_line) {
                entries.push(ConfigEntry {
                    key,
                    value,
                    scope,
                    file: Some(path.to_path_buf()),
                    line: start_idx + 1,
                });
            }
        }

        (entries, None)
    }

    /// Last value for `key` in this file only (canonical key, case-insensitive section/var like Git).
    #[must_use]
    pub fn get(&self, key: &str) -> Option<String> {
        let canon = canonical_key(key).ok()?;
        self.entries
            .iter()
            .rev()
            .find(|e| e.key == canon)
            .map(|e| e.value.clone().unwrap_or_else(|| "true".to_owned()))
    }

    /// Parse like [`Self::parse`] but record a non-disk include origin (blob, stdin, command line).
    pub fn parse_with_origin(
        path: &Path,
        content: &str,
        scope: ConfigScope,
        include_origin: ConfigIncludeOrigin,
    ) -> Result<Self> {
        let mut f = Self::parse(path, content, scope)?;
        f.include_origin = include_origin;
        Ok(f)
    }

    /// Build a synthetic [`ConfigFile`] from `GIT_CONFIG_PARAMETERS` / `git -c` payloads.
    ///
    /// Unlike [`Self::parse`], this accepts flat `key=value` assignments without `[section]`
    /// headers, matching how Git injects command-line configuration.
    pub fn from_git_config_parameters(path: &Path, raw: &str) -> Result<Self> {
        let mut entries = Vec::new();
        for entry in parse_config_parameters_strict(raw)? {
            match entry {
                ConfigParameter::Pair { key, value } => {
                    let canon = canonical_key(key.trim())?;
                    entries.push(ConfigEntry {
                        key: canon,
                        value,
                        scope: ConfigScope::Command,
                        file: None,
                        line: 0,
                    });
                }
                ConfigParameter::OldStyle(entry) => {
                    if let Some((key, val)) = entry.split_once('=') {
                        let canon = canonical_key(key.trim())?;
                        entries.push(ConfigEntry {
                            key: canon,
                            value: Some(val.to_owned()),
                            scope: ConfigScope::Command,
                            file: None,
                            line: 0,
                        });
                    } else {
                        let canon = canonical_key(entry.trim())?;
                        entries.push(ConfigEntry {
                            key: canon,
                            value: None,
                            scope: ConfigScope::Command,
                            file: None,
                            line: 0,
                        });
                    }
                }
            }
        }
        Ok(Self {
            path: path.to_path_buf(),
            scope: ConfigScope::Command,
            entries,
            raw_lines: Vec::new(),
            include_origin: ConfigIncludeOrigin::CommandLine,
        })
    }

    /// Read and parse a config file from disk.
    ///
    /// Returns `Ok(None)` if the file does not exist.
    ///
    /// # Errors
    ///
    /// Returns [`Error::Io`] on read failure (other than not-found) or
    /// [`Error::Config`] on parse failure.
    pub fn from_path(path: &Path, scope: ConfigScope) -> Result<Option<Self>> {
        match fs::read_to_string(path) {
            Ok(content) => Ok(Some(Self::parse(path, &content, scope)?)),
            Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
            Err(e) => Err(Error::Io(e)),
        }
    }

    /// Set a value in this config file, creating the section if needed.
    ///
    /// If the key already exists, its last occurrence is updated in-place.
    /// Otherwise a new entry is appended (creating the section header if
    /// necessary).
    ///
    /// # Parameters
    ///
    /// - `key` — canonical key (e.g. `core.bare`).
    /// - `value` — the value to set.
    pub fn set(&mut self, key: &str, value: &str) -> Result<()> {
        self.set_with_comment(key, value, None)
    }

    /// Set a value in this config file, optionally appending an inline comment.
    pub fn set_with_comment(
        &mut self,
        key: &str,
        value: &str,
        comment: Option<&str>,
    ) -> Result<()> {
        let canon = canonical_key(key)?;
        if self.entries.iter().filter(|e| e.key == canon).count() > 1 {
            return Err(Error::Config(ConfigError::MultipleValues {
                key: key.to_owned(),
            }));
        }
        let raw_var = raw_variable_name(key);
        let comment_suffix = format_comment_suffix(comment)?;

        // Find the last entry with this key to replace in-place.
        let existing_idx = self.entries.iter().rposition(|e| e.key == canon);

        if let Some(idx) = existing_idx {
            let line_idx = self.entries[idx].line - 1;
            let raw_line = &self.raw_lines[line_idx];
            if is_section_header_with_inline_entry(raw_line) {
                // Entry is on the same line as a section header — split it
                let header_only = extract_section_header(raw_line);
                self.raw_lines[line_idx] = header_only;
                let new_line = format!("\t{} = {}{}", raw_var, escape_value(value), comment_suffix);
                self.raw_lines.insert(line_idx + 1, new_line);
                // Re-parse to fix up entries and line numbers
                let content = self.raw_lines.join("\n");
                let reparsed = Self::parse(&self.path, &content, self.scope)?;
                self.entries = reparsed.entries;
                self.raw_lines = reparsed.raw_lines;
            } else {
                self.raw_lines[line_idx] =
                    format!("\t{} = {}{}", raw_var, escape_value(value), comment_suffix);
                self.entries[idx].value = Some(value.to_owned());
            }
        } else {
            // Need to add: find or create the section
            let (section, subsection, _var) = split_key(&canon)?;
            let (raw_sec, raw_sub) = raw_section_parts(key);
            let section_line = self.find_or_create_section_preserving_case(
                &section,
                subsection.as_deref(),
                &raw_sec,
                raw_sub.as_deref(),
            );
            let new_line = format!("\t{} = {}{}", raw_var, escape_value(value), comment_suffix);

            // Insert after the section header (or last entry in section)
            let insert_at = self.last_line_in_section(section_line) + 1;
            self.raw_lines.insert(insert_at, new_line);

            // Re-parse to fix up line numbers
            let content = self.raw_lines.join("\n");
            let reparsed = Self::parse(&self.path, &content, self.scope)?;
            self.entries = reparsed.entries;
            self.raw_lines = reparsed.raw_lines;
        }

        Ok(())
    }

    /// Replace ALL occurrences of a key with a new value.
    ///
    /// Removes all but the last occurrence from the file, then updates
    /// the last occurrence with the new value (matching Git behaviour).
    pub fn replace_all(
        &mut self,
        key: &str,
        value: &str,
        value_pattern: Option<&str>,
    ) -> Result<()> {
        self.replace_all_with_comment(key, value, value_pattern, None)
    }

    /// Replace all occurrences, optionally appending an inline comment.
    ///
    /// Value patterns starting with `!` are treated as negated regex
    /// (matching values that do NOT match the pattern).
    pub fn replace_all_with_comment(
        &mut self,
        key: &str,
        value: &str,
        value_pattern: Option<&str>,
        comment: Option<&str>,
    ) -> Result<()> {
        let canon = canonical_key(key)?;
        let comment_suffix = format_comment_suffix(comment)?;

        let (re, negated) = match value_pattern {
            Some(pat) => {
                let (compiled, neg) = compile_config_value_pattern(pat)?;
                (Some(compiled), neg)
            }
            None => (None, false),
        };

        // Find all matching entries (by key, and optionally by value pattern)
        let matching_indices: Vec<usize> = self
            .entries
            .iter()
            .enumerate()
            .filter(|(_, e)| {
                if e.key != canon {
                    return false;
                }
                if let Some(ref re) = re {
                    let v = e.value.as_deref().unwrap_or("");
                    value_matches_config_pattern(re, negated, v)
                } else {
                    true
                }
            })
            .map(|(i, _)| i)
            .collect();

        let Some(&target_idx) = matching_indices.last() else {
            // No matching entries — add a new one at the end of the section
            return self.add_value_with_comment(key, value, comment);
        };

        let raw_var = raw_variable_name(key);

        let target_line_idx = self.entries[target_idx].line - 1;
        let raw_line = &self.raw_lines[target_line_idx];
        if is_section_header_with_inline_entry(raw_line) {
            let header = extract_section_header(raw_line);
            self.raw_lines[target_line_idx] = header;
            let new_line = format!("\t{} = {}{}", raw_var, escape_value(value), comment_suffix);
            self.raw_lines.insert(target_line_idx + 1, new_line);
        } else {
            self.raw_lines[target_line_idx] =
                format!("\t{} = {}{}", raw_var, escape_value(value), comment_suffix);
        }

        for &idx in matching_indices.iter().rev() {
            if idx == target_idx {
                continue;
            }
            let line_idx = self.entries[idx].line - 1;
            self.remove_entry_line(line_idx);
        }

        // Re-parse
        let content = self.raw_lines.join("\n");
        let reparsed = Self::parse(&self.path, &content, self.scope)?;
        self.entries = reparsed.entries;
        self.raw_lines = reparsed.raw_lines;

        Ok(())
    }

    /// Count how many entries exist for a key.
    pub fn count(&self, key: &str) -> Result<usize> {
        let canon = canonical_key(key)?;
        Ok(self.entries.iter().filter(|e| e.key == canon).count())
    }

    /// Remove an entry at the given raw line index.
    ///
    /// If the line is a section header with an inline entry, only the inline
    /// portion is removed (the header is kept). Otherwise the entire line is
    /// removed. Also removes continuation lines following the entry.
    /// Remove an entry at the given raw line index.
    ///
    /// If the line is a section header with an inline entry, only the inline
    /// portion is removed (the header is kept). Otherwise the entire line
    /// (and any continuation lines) is removed.
    fn remove_entry_line(&mut self, line_idx: usize) {
        if is_section_header_with_inline_entry(&self.raw_lines[line_idx]) {
            // Keep the section header, strip the inline entry
            let header = extract_section_header(&self.raw_lines[line_idx]);
            self.raw_lines[line_idx] = header;
        } else {
            // Check if this line has continuation lines and remove them too
            let mut lines_to_remove = 1;
            let mut check_line = self.raw_lines[line_idx].clone();
            while value_line_continues(&check_line)
                && (line_idx + lines_to_remove) < self.raw_lines.len()
            {
                check_line = self.raw_lines[line_idx + lines_to_remove].clone();
                lines_to_remove += 1;
            }
            for _ in 0..lines_to_remove {
                self.raw_lines.remove(line_idx);
            }
        }
    }

    /// Unset (remove) only the last occurrence of a key.
    ///
    /// Returns the number of entries removed (0 or 1).
    pub fn unset_last(&mut self, key: &str) -> Result<usize> {
        let canon = canonical_key(key)?;
        let last_idx = self.entries.iter().rposition(|e| e.key == canon);

        if let Some(idx) = last_idx {
            let line_idx = self.entries[idx].line - 1;
            self.remove_entry_line(line_idx);
            let (section, subsection, _) = split_key(&canon)?;
            self.remove_empty_section_headers_matching(&section, subsection.as_deref());
            let content = self.raw_lines.join("\n");
            let reparsed = Self::parse(&self.path, &content, self.scope)?;
            self.entries = reparsed.entries;
            self.raw_lines = reparsed.raw_lines;
            Ok(1)
        } else {
            Ok(0)
        }
    }

    /// Unset (remove) all occurrences of a key.
    ///
    /// # Parameters
    ///
    /// - `key` — canonical key (e.g. `core.bare`).
    ///
    /// # Returns
    ///
    /// The number of entries removed.
    pub fn unset(&mut self, key: &str) -> Result<usize> {
        let canon = canonical_key(key)?;
        let line_indices: Vec<usize> = self
            .entries
            .iter()
            .filter(|e| e.key == canon)
            .map(|e| e.line - 1)
            .collect();

        let count = line_indices.len();
        // Remove from bottom to top to keep indices valid
        for &idx in line_indices.iter().rev() {
            self.remove_entry_line(idx);
        }

        if count > 0 {
            if let Ok((section, subsection, _)) = split_key(&canon) {
                self.remove_empty_section_headers_matching(&section, subsection.as_deref());
            }
            let content = self.raw_lines.join("\n");
            let reparsed = Self::parse(&self.path, &content, self.scope)?;
            self.entries = reparsed.entries;
            self.raw_lines = reparsed.raw_lines;
        }

        Ok(count)
    }

    /// Unset entries matching a key and optional value-pattern regex.
    ///
    /// If `value_pattern` is `None`, removes all entries with the given key.
    /// If `value_pattern` is `Some(pat)`, only removes entries whose value matches the regex.
    ///
    /// When `preserve_empty_section_header` is `true`, a section header is kept even if the
    /// section has no remaining keys (Git's `config unset --all`). When `false`, empty sections
    /// are stripped (`config --unset`, `config --unset-all`, and value-pattern unsets).
    pub fn unset_matching(
        &mut self,
        key: &str,
        value_pattern: Option<&str>,
        preserve_empty_section_header: bool,
    ) -> Result<usize> {
        let canon = canonical_key(key)?;
        let pattern = match value_pattern {
            Some(pat) => {
                let (re, negated) = compile_config_value_pattern(pat)?;
                Some((re, negated))
            }
            None => None,
        };

        let line_indices: Vec<usize> = self
            .entries
            .iter()
            .filter(|e| {
                if e.key != canon {
                    return false;
                }
                if let Some((ref re, negated)) = pattern {
                    let v = e.value.as_deref().unwrap_or("");
                    value_matches_config_pattern(re, negated, v)
                } else {
                    true
                }
            })
            .map(|e| e.line - 1)
            .collect();

        let count = line_indices.len();
        for &idx in line_indices.iter().rev() {
            self.remove_entry_line(idx);
        }

        if count > 0 {
            if !preserve_empty_section_header {
                let (section, subsection, _) = split_key(&canon)?;
                self.remove_empty_section_headers_matching(&section, subsection.as_deref());
            }

            let content = self.raw_lines.join("\n");
            let reparsed = Self::parse(&self.path, &content, self.scope)?;
            self.entries = reparsed.entries;
            self.raw_lines = reparsed.raw_lines;
        }

        Ok(count)
    }

    /// Remove an entire section (and all its entries).
    ///
    /// # Parameters
    ///
    /// - `section` — section name (e.g. `"core"`, `"remote.origin"`).
    pub fn remove_section(&mut self, section: &str) -> Result<bool> {
        let (sec_name, sub_name) = parse_section_name(section);
        let sec_lower = sec_name.to_lowercase();

        let mut remove = vec![false; self.raw_lines.len()];
        let mut removing = false;
        let mut found = false;
        let mut parser = Parser::new();

        for (idx, line) in self.raw_lines.iter().enumerate() {
            if parser.try_parse_section(line) {
                removing = section_matches(&parser, &sec_lower, sub_name);
                found |= removing;
            }
            if removing {
                remove[idx] = true;
            }
        }

        if found {
            self.raw_lines = self
                .raw_lines
                .iter()
                .enumerate()
                .filter_map(|(idx, line)| (!remove[idx]).then_some(line.clone()))
                .collect();
            let content = self.raw_lines.join("\n");
            let reparsed = Self::parse(&self.path, &content, self.scope)?;
            self.entries = reparsed.entries;
            self.raw_lines = reparsed.raw_lines;
            Ok(true)
        } else {
            Ok(false)
        }
    }

    /// Rename a section.
    ///
    /// # Parameters
    ///
    /// - `old_name` — current section name (e.g. `"branch.main"`).
    /// - `new_name` — new section name (e.g. `"branch.develop"`).
    pub fn rename_section(&mut self, old_name: &str, new_name: &str) -> Result<bool> {
        let (old_sec, old_sub) = parse_section_name(old_name);
        let (new_sec, new_sub) = parse_section_name(new_name);
        validate_section_name(new_name, new_sec, new_sub)?;
        let old_lower = old_sec.to_lowercase();

        let mut found = false;
        let mut parser = Parser::new();

        let mut idx = 0usize;
        while idx < self.raw_lines.len() {
            let line = self.raw_lines[idx].clone();
            let mut inline_remainder = None;
            if parser.try_parse_section_with_remainder(&line, &mut inline_remainder)
                && section_matches(&parser, &old_lower, old_sub)
            {
                // Rewrite the section header
                let header = match new_sub {
                    Some(sub) => format!("[{} \"{}\"]", new_sec, sub),
                    None => format!("[{}]", new_sec),
                };
                self.raw_lines[idx] = header;
                if let Some(remainder) = inline_remainder {
                    self.raw_lines
                        .insert(idx + 1, format!("\t{}", remainder.trim()));
                    idx += 1;
                }
                found = true;
            }
            idx += 1;
        }

        if found {
            let content = self.raw_lines.join("\n");
            let reparsed = Self::parse(&self.path, &content, self.scope)?;
            self.entries = reparsed.entries;
            self.raw_lines = reparsed.raw_lines;
        }

        Ok(found)
    }

    /// Append a new value for a key without removing existing entries.
    ///
    /// This is the behaviour of `git config --add section.key value`.
    /// If the section doesn't exist, it is created.
    pub fn add_value(&mut self, key: &str, value: &str) -> Result<()> {
        self.add_value_with_comment(key, value, None)
    }

    /// Append a new value with an optional inline comment.
    pub fn add_value_with_comment(
        &mut self,
        key: &str,
        value: &str,
        comment: Option<&str>,
    ) -> Result<()> {
        let canon = canonical_key(key)?;
        let raw_var = raw_variable_name(key);
        let comment_suffix = format_comment_suffix(comment)?;
        let (section, subsection, _var) = split_key(&canon)?;
        let (raw_sec, raw_sub) = raw_section_parts(key);

        let section_line = self.find_or_create_section_preserving_case(
            &section,
            subsection.as_deref(),
            &raw_sec,
            raw_sub.as_deref(),
        );
        let new_line = format!("\t{} = {}{}", raw_var, escape_value(value), comment_suffix);
        let insert_at = self.last_line_in_section(section_line) + 1;
        self.raw_lines.insert(insert_at, new_line);

        // Re-parse to fix up entries and line numbers
        let content = self.raw_lines.join("\n");
        let reparsed = Self::parse(&self.path, &content, self.scope)?;
        self.entries = reparsed.entries;
        self.raw_lines = reparsed.raw_lines;

        Ok(())
    }

    /// Write the (possibly modified) config back to disk.
    /// Remove section headers that have no remaining entries or comments.
    fn remove_empty_section_headers_matching(&mut self, section: &str, subsection: Option<&str>) {
        let (Ok(section_re), Ok(comment_re)) = (
            regex::Regex::new(r"^\s*\["),
            regex::Regex::new(r"^\s*(#|;)"),
        ) else {
            // Static patterns: compilation cannot fail in practice; bail out safely.
            return;
        };

        let mut to_remove: Vec<usize> = Vec::new();
        let len = self.raw_lines.len();
        let section_lower = section.to_lowercase();
        let mut parser = Parser::new();

        for i in 0..len {
            let line = &self.raw_lines[i];
            if !section_re.is_match(line) {
                continue;
            }
            if !parser.try_parse_section(line)
                || !section_matches(&parser, &section_lower, subsection)
            {
                continue;
            }
            // Don't remove section headers that have inline key=value entries
            if is_section_header_with_inline_entry(line) {
                continue;
            }
            let has_attached_leading_comment = self.raw_lines[..i]
                .iter()
                .enumerate()
                .rev()
                .find(|(_, line)| !line.trim().is_empty())
                .is_some_and(|(idx, line)| {
                    comment_re.is_match(line)
                        && idx
                            .checked_sub(1)
                            .is_none_or(|prev| !value_line_continues(&self.raw_lines[prev]))
                });
            if has_attached_leading_comment {
                continue;
            }
            // Check if this section header is followed only by blank lines,
            // comments, or another section header (or end of file).
            let mut has_entries = false;
            for j in (i + 1)..len {
                let next = self.raw_lines[j].trim();
                if next.is_empty() {
                    continue;
                }
                if section_re.is_match(&self.raw_lines[j]) {
                    break;
                }
                if comment_re.is_match(&self.raw_lines[j]) {
                    // Has comments — keep the section
                    has_entries = true;
                    break;
                }
                // Has a key-value entry
                has_entries = true;
                break;
            }
            if !has_entries {
                to_remove.push(i);
            }
        }

        // Remove in reverse to preserve indices
        for &idx in to_remove.iter().rev() {
            self.raw_lines.remove(idx);
        }

        // Also remove trailing blank lines
        while self.raw_lines.last().is_some_and(|l| l.trim().is_empty()) {
            self.raw_lines.pop();
        }
    }

    /// Write the file back to [`Self::path`] through `{path}.lock` and an atomic rename.
    ///
    /// The existing file's permission bits are kept. Like Git, which has no `core.fsync`
    /// component for config files, the lock file is not fsynced before the rename: readers
    /// always see either the old or the new file, but a crash may lose the update.
    ///
    /// # Errors
    ///
    /// Returns [`Error::Io`] on write failure, or [`ConfigError::ConfigFileLocked`] when
    /// `{path}.lock` already exists.
    pub fn write(&self) -> Result<()> {
        let lock_path = config_lock_path(&self.path);
        let content = self.raw_lines.join("\n");
        let bytes: Vec<u8> = if content.trim().is_empty() {
            Vec::new()
        } else if content.ends_with('\n') {
            content.into_bytes()
        } else {
            format!("{content}\n").into_bytes()
        };

        let mut lock_file = fs::OpenOptions::new()
            .write(true)
            .create_new(true)
            .open(&lock_path)
            .map_err(|e| {
                if e.kind() == std::io::ErrorKind::AlreadyExists {
                    Error::Config(ConfigError::ConfigFileLocked {
                        path: lock_path.display().to_string(),
                    })
                } else {
                    Error::Io(e)
                }
            })?;

        #[cfg(unix)]
        if let Ok(meta) = fs::metadata(&self.path) {
            let _ = lock_file.set_permissions(meta.permissions());
        }

        use std::io::Write as _;
        lock_file.write_all(&bytes).map_err(|e| {
            let _ = fs::remove_file(&lock_path);
            Error::Io(e)
        })?;
        drop(lock_file);

        fs::rename(&lock_path, &self.path).map_err(|e| {
            let _ = fs::remove_file(&lock_path);
            Error::Io(e)
        })?;
        Ok(())
    }

    /// Find the line index of a section header (case-insensitive match),
    /// or create one using the original-case names from user input.
    fn find_or_create_section_preserving_case(
        &mut self,
        section: &str,
        subsection: Option<&str>,
        raw_section: &str,
        raw_subsection: Option<&str>,
    ) -> usize {
        let sec_lower = section.to_lowercase();
        let mut parser = Parser::new();
        let mut last_match = None;

        for (idx, line) in self.raw_lines.iter().enumerate() {
            if parser.try_parse_section(line) && section_matches(&parser, &sec_lower, subsection) {
                last_match = Some(idx);
            }
        }
        if let Some(idx) = last_match {
            return idx;
        }

        // Create new section at end of file, using original case
        let header = match raw_subsection {
            Some(sub) => {
                let escaped = escape_subsection(sub);
                format!("[{} \"{}\"]", raw_section, escaped)
            }
            None => format!("[{}]", raw_section),
        };
        self.raw_lines.push(header);
        self.raw_lines.len() - 1
    }

    /// Find the last line that belongs to the section starting at `section_line`.
    fn last_line_in_section(&self, section_line: usize) -> usize {
        let mut last = section_line;
        for idx in (section_line + 1)..self.raw_lines.len() {
            let trimmed = self.raw_lines[idx].trim();
            if trimmed.starts_with('[') {
                break;
            }
            last = idx;
        }
        last
    }
}

// ── ConfigSet ───────────────────────────────────────────────────────

impl ConfigSet {
    /// Create an empty config set.
    #[must_use]
    pub fn new() -> Self {
        Self {
            entries: Vec::new(),
        }
    }

    /// All merged entries in load order (for listing keys such as `alias.*`).
    #[must_use]
    pub fn entries(&self) -> &[ConfigEntry] {
        &self.entries
    }

    /// Merge entries from a [`ConfigFile`] into this set.
    ///
    /// Entries are appended; later values override earlier ones for
    /// single-value lookups.
    pub fn merge(&mut self, file: &ConfigFile) {
        self.entries.extend(file.entries.iter().cloned());
    }

    /// Merge another [`ConfigSet`] into this set (entries appended in order).
    pub fn merge_set(&mut self, other: &ConfigSet) {
        self.entries.extend(other.entries.iter().cloned());
    }

    /// Add a command-line override (`-c key=value`).
    pub fn add_command_override(&mut self, key: &str, value: &str) -> Result<()> {
        let canon = canonical_key(key)?;
        self.entries.push(ConfigEntry {
            key: canon,
            value: Some(value.to_owned()),
            scope: ConfigScope::Command,
            file: None,
            line: 0,
        });
        Ok(())
    }

    /// Get the last (highest-priority) value for a key.
    ///
    /// # Parameters
    ///
    /// - `key` — the key to look up (will be canonicalized).
    ///
    /// # Returns
    ///
    /// `Some(value)` for the last matching entry, or `None` if not found.
    /// Bare boolean keys return `Some("true")`.
    #[must_use]
    pub fn get(&self, key: &str) -> Option<String> {
        let canon = canonical_key(key).ok()?;
        self.entries
            .iter()
            .rev()
            .find(|e| e.key == canon)
            .map(|e| e.value.clone().unwrap_or_else(|| "true".to_owned()))
    }

    /// Last (highest-priority) [`ConfigEntry`] for a key, including origin metadata.
    ///
    /// Bare boolean keys are returned with [`ConfigEntry::value`] set to `None` (same as `get`,
    /// which maps them to `"true"` for string lookups).
    #[must_use]
    pub fn get_last_entry(&self, key: &str) -> Option<ConfigEntry> {
        let canon = canonical_key(key).ok()?;
        self.entries.iter().rev().find(|e| e.key == canon).cloned()
    }

    /// Winning value for `key` plus scope, source file, and line (Git `--show-origin --show-scope`).
    ///
    /// # Errors
    ///
    /// Returns [`Error::Config`] when `key` is not a valid Git config key.
    pub fn get_with_origin(&self, key: &str) -> Result<Option<ConfigValueOrigin>> {
        let _canon = canonical_key(key)?;
        Ok(self.get_last_entry(key).map(|e| ConfigValueOrigin {
            value: e.value.clone().or_else(|| Some("true".to_owned())),
            scope: e.scope,
            file: config_entry_origin_file(&e).map(Path::to_path_buf),
            line: config_entry_origin_line(&e),
        }))
    }

    /// Every value for `key` in load order, with origin metadata (Git `--get-all`).
    ///
    /// # Errors
    ///
    /// Returns [`Error::Config`] when `key` is not a valid Git config key.
    pub fn get_all_with_origin(&self, key: &str) -> Result<Vec<ConfigValueOrigin>> {
        let canon = canonical_key(key)?;
        Ok(self
            .entries
            .iter()
            .filter(|e| e.key == canon)
            .map(|e| ConfigValueOrigin {
                value: e.value.clone().or_else(|| Some("true".to_owned())),
                scope: e.scope,
                file: config_entry_origin_file(e).map(Path::to_path_buf),
                line: config_entry_origin_line(e),
            })
            .collect())
    }

    /// Get all values for a key (multi-valued; in load order).
    #[must_use]
    pub fn get_all(&self, key: &str) -> Vec<String> {
        let canon = match canonical_key(key) {
            Ok(c) => c,
            Err(_) => return Vec::new(),
        };
        self.entries
            .iter()
            .filter(|e| e.key == canon)
            .map(|e| e.value.clone().unwrap_or_default())
            .collect()
    }

    /// All raw values for a key in load order, preserving `None` for bare boolean keys.
    ///
    /// Matches Git's multi-value list where `NULL` means a value-less / boolean-true key.
    #[must_use]
    pub fn get_all_raw(&self, key: &str) -> Vec<Option<String>> {
        let canon = match canonical_key(key) {
            Ok(c) => c,
            Err(_) => return Vec::new(),
        };
        self.entries
            .iter()
            .filter(|e| e.key == canon)
            .map(|e| e.value.clone())
            .collect()
    }

    /// True if any config entry uses `key` (after canonicalization), including bare boolean keys.
    ///
    /// Unlike [`Self::get`], this does not treat a missing value as `"true"` — it reports whether
    /// the key appears in the merged config at all (Git `repo_config_get` / `git_configset_get`).
    #[must_use]
    pub fn has_key(&self, key: &str) -> bool {
        let Ok(canon) = canonical_key(key) else {
            return false;
        };
        self.entries.iter().any(|e| e.key == canon)
    }

    /// Get a boolean value, interpreting `true`/`yes`/`on`/`1` as true and
    /// `false`/`no`/`off`/`0` as false.
    ///
    /// `pack.allowPackReuse` may be `single` or `multi` (Git enum, not a bool). Those values are
    /// treated as unset for boolean lookup so `get_bool` does not error during broad config scans.
    ///
    /// # Returns
    ///
    /// `None` when `key` is unset, otherwise the parsed value.
    ///
    /// # Errors
    ///
    /// [`ConfigError::InvalidValue`] naming `key` when the value is not a Git boolean.
    pub fn get_bool(&self, key: &str) -> Option<std::result::Result<bool, ConfigError>> {
        let v = self.get(key)?;
        if canonical_key(key).ok().as_deref() == Some("pack.allowpackreuse") {
            let lower = v.trim().to_ascii_lowercase();
            if lower == "single" || lower == "multi" {
                return None;
            }
        }
        Some(parse_bool(&v).map_err(|e| e.for_key(key)))
    }

    /// Get a boolean value, falling back to `default` when `key` is unset or its value is not a
    /// Git boolean.
    ///
    /// Use this for settings where Git also ignores a malformed value; use [`Self::get_bool`]
    /// with `transpose()?` when a bad value must be reported.
    ///
    /// # Parameters
    ///
    /// - `key`: dotted config key, matched case-insensitively in its section and variable name.
    /// - `default`: the value Git uses when the key is unset.
    #[must_use]
    pub fn bool_or(&self, key: &str, default: bool) -> bool {
        self.get_bool(key)
            .and_then(std::result::Result::ok)
            .unwrap_or(default)
    }

    /// Whether path comparisons fold ASCII case (`core.ignoreCase`, default `false`).
    #[must_use]
    pub fn ignore_case(&self) -> bool {
        self.bool_or("core.ignoreCase", false)
    }

    /// Whether paths are stored NFC-precomposed (`core.precomposeUnicode`, default `false`).
    ///
    /// This is the value in this set only; callers that may not have a loaded set use
    /// `effective_core_precomposeunicode_with_config`.
    #[must_use]
    pub fn precompose_unicode(&self) -> bool {
        self.bool_or("core.precomposeUnicode", false)
    }

    /// Whether index refresh may stat entries in parallel (`core.preloadIndex`, default `true`).
    #[must_use]
    pub fn preload_index(&self) -> bool {
        self.bool_or("core.preloadIndex", true)
    }

    /// Whether the executable bit in the work tree is trusted (`core.fileMode`, default `true`).
    #[must_use]
    pub fn file_mode(&self) -> bool {
        self.bool_or("core.fileMode", true)
    }

    /// Whether pathnames in human-readable output should fully C-quote non-ASCII bytes as octal.
    ///
    /// Maps to Git's `quote_path_fully` (`core.quotePath`, default true). When false, UTF-8 and
    /// other high bytes are emitted literally; only ASCII specials are escaped.
    #[must_use]
    pub fn quote_path_fully(&self) -> bool {
        self.bool_or("core.quotePath", true)
    }

    /// Default for `pack.writeBitmapHashCache` (Git default: true).
    #[must_use]
    pub fn pack_write_bitmap_hash_cache(&self) -> bool {
        self.bool_or("pack.writeBitmapHashCache", true)
    }

    /// Default for `pack.writeBitmapLookupTable` (Git default: false).
    #[must_use]
    pub fn pack_write_bitmap_lookup_table(&self) -> bool {
        self.bool_or("pack.writeBitmapLookupTable", false)
    }

    /// Values of `pack.preferBitmapTips` (may appear multiple times).
    #[must_use]
    pub fn pack_prefer_bitmap_tips(&self) -> Vec<String> {
        let mut out = self.get_all("pack.preferbitmaptips");
        if out.is_empty() {
            out = self.get_all("pack.preferBitmapTips");
        }
        out
    }

    /// Build [`crate::pack_bitmap::PackBitmapWriteOptions`] from config keys.
    #[must_use]
    pub fn pack_bitmap_write_options(&self) -> crate::pack_bitmap::PackBitmapWriteOptions {
        crate::pack_bitmap::PackBitmapWriteOptions {
            full_dag: true,
            hash_cache: self.pack_write_bitmap_hash_cache(),
            lookup_table: self.pack_write_bitmap_lookup_table(),
            prefer_bitmap_tips: self.pack_prefer_bitmap_tips(),
            verify_reachability_closure: true,
            reachability_roots: None,
        }
    }

    /// Default for `pack.writeReverseIndex` / `pack.writereverseindex` (Git default: true).
    #[must_use]
    pub fn pack_write_reverse_index_default(&self) -> bool {
        if self
            .get("pack.writeReverseIndex")
            .is_some_and(|v| v.trim().is_empty())
        {
            return false;
        }
        self.bool_or("pack.writeReverseIndex", true)
    }

    /// Resolved worker count for pack indexing (`pack.threads`, Git default: unset → all CPUs).
    #[must_use]
    pub fn pack_index_threads(&self) -> Option<usize> {
        self.get_i64("pack.threads")
            .and_then(|r| r.ok())
            .and_then(|n| usize::try_from(n).ok())
    }

    /// In-pack delta window (`pack.window`, Git default: 10 when unset).
    ///
    /// An explicit `0` disables newly computed deltas (on-disk reuse may still apply).
    #[must_use]
    pub fn pack_object_window(&self) -> usize {
        match self.get_i64("pack.window") {
            None => 10,
            Some(Ok(n)) if n >= 0 => usize::try_from(n).unwrap_or(10),
            Some(Ok(_)) | Some(Err(_)) => 10,
        }
    }

    /// In-pack delta chain depth cap (`pack.depth`, Git default: 50 when unset).
    ///
    /// An explicit `0` disables newly computed deltas (on-disk reuse may still apply).
    #[must_use]
    /// Sliding-window memory cap for delta search (`pack.windowMemory`, Git default: unlimited).
    pub fn pack_window_memory_bytes(&self) -> u64 {
        match self.get_i64("pack.windowmemory") {
            None => 0,
            Some(Ok(n)) if n >= 0 => u64::try_from(n).unwrap_or(0),
            Some(Ok(_)) | Some(Err(_)) => 0,
        }
    }

    /// Maximum delta depth for `git pack-objects` (`pack.depth`, Git default 50).
    pub fn pack_object_depth(&self) -> usize {
        match self.get_i64("pack.depth") {
            None => crate::pack::DEFAULT_PACK_DEPTH,
            Some(Ok(n)) if n >= 0 => usize::try_from(n).unwrap_or(crate::pack::DEFAULT_PACK_DEPTH),
            Some(Ok(_)) | Some(Err(_)) => crate::pack::DEFAULT_PACK_DEPTH,
        }
    }

    /// Approximate loose-object count above which automatic maintenance packs loose objects
    /// (`gc.auto`, Git default 6700).
    ///
    /// Returns `None` when `gc.auto` is zero or negative, which turns off automatic maintenance
    /// entirely (including the [`Self::gc_auto_pack_limit`] trigger). Unparsable values fall
    /// back to the default.
    #[must_use]
    pub fn gc_auto_threshold(&self) -> Option<usize> {
        match self.get_i64("gc.auto") {
            Some(Ok(n)) if n <= 0 => None,
            Some(Ok(n)) => Some(usize::try_from(n).unwrap_or(usize::MAX)),
            None | Some(Err(_)) => Some(DEFAULT_GC_AUTO_THRESHOLD),
        }
    }

    /// Number of non-`.keep` local packs above which automatic maintenance consolidates every
    /// pack into one (`gc.autoPackLimit`, Git default 50).
    ///
    /// Returns `None` when the value is zero or negative (pack consolidation trigger off).
    /// Unparsable values fall back to the default.
    #[must_use]
    pub fn gc_auto_pack_limit(&self) -> Option<usize> {
        match self.get_i64("gc.autoPackLimit") {
            Some(Ok(n)) if n <= 0 => None,
            Some(Ok(n)) => Some(usize::try_from(n).unwrap_or(usize::MAX)),
            None | Some(Err(_)) => Some(DEFAULT_GC_AUTO_PACK_LIMIT),
        }
    }

    /// Whether automatic maintenance runs in a detached background process
    /// (`gc.autoDetach`, default `true`).
    #[must_use]
    pub fn gc_auto_detach(&self) -> bool {
        self.bool_or("gc.autoDetach", true)
    }

    /// Whether commands may start automatic maintenance at all (`maintenance.auto`, default
    /// `true`).
    #[must_use]
    pub fn maintenance_auto(&self) -> bool {
        self.bool_or("maintenance.auto", true)
    }

    /// [`crate::hash::Parallelism`] for pack indexing from merged config.
    ///
    /// # Errors
    ///
    /// Returns [`ConfigError`] when `pack.threads` is set to a value Git rejects.
    pub fn try_pack_index_parallelism(
        &self,
    ) -> std::result::Result<crate::parallel::Parallelism, ConfigError> {
        Ok(crate::parallel::ThreadPolicy::default()
            .try_resolve(crate::parallel::ParallelOp::IndexPack, self)?
            .parallelism())
    }

    /// Like [`Self::try_pack_index_parallelism`], but an invalid `pack.threads`
    /// falls back to the default (all available cores) instead of an error.
    #[must_use]
    pub fn pack_index_parallelism(&self) -> crate::parallel::Parallelism {
        self.try_pack_index_parallelism()
            .unwrap_or_else(|_| crate::parallel::Parallelism::resolve(None))
    }

    /// Load config for `git_dir` (if any) and resolve [`crate::hash::Parallelism`] for index-pack.
    ///
    /// # Errors
    ///
    /// Propagates config load failures and invalid `pack.threads`.
    pub fn try_pack_index_parallelism_for_git_dir(
        env: &Environment,
        git_dir: Option<&std::path::Path>,
    ) -> Result<crate::parallel::Parallelism> {
        match git_dir {
            Some(d) => {
                let cfg = Self::load(env, Some(d), true)?;
                Ok(cfg.try_pack_index_parallelism()?)
            }
            None => Ok(crate::parallel::Parallelism::resolve(None)),
        }
    }

    /// Load config for `git_dir` (if any) and resolve [`crate::hash::Parallelism`] for index-pack.
    #[must_use]
    pub fn pack_index_parallelism_for_git_dir(
        env: &Environment,
        git_dir: Option<&std::path::Path>,
    ) -> crate::parallel::Parallelism {
        Self::try_pack_index_parallelism_for_git_dir(env, git_dir)
            .unwrap_or_else(|_| crate::parallel::Parallelism::resolve(None))
    }

    /// Default for `pack.readReverseIndex` / `pack.readreverseindex` (Git default: true).
    #[must_use]
    pub fn pack_read_reverse_index_default(&self) -> bool {
        self.bool_or("pack.readReverseIndex", true)
    }

    /// `core.logAllRefUpdates` as configured in this set, or [`refs::LogRefsConfig::Unset`] when
    /// the key is absent or holds an unrecognised value.
    #[must_use]
    pub(crate) fn log_refs_config(&self) -> refs::LogRefsConfig {
        self.get("core.logAllRefUpdates")
            .and_then(|v| refs::LogRefsConfig::parse(&v))
            .unwrap_or(refs::LogRefsConfig::Unset)
    }

    /// Resolved `core.logAllRefUpdates` using this merged set (includes `git -c` / env), then Git's
    /// bare-repo default when the key is unset everywhere.
    ///
    /// Never returns [`refs::LogRefsConfig::Unset`]: an unset (or unrecognised) value resolves to
    /// [`refs::LogRefsConfig::None`] in a bare repository and [`refs::LogRefsConfig::Normal`]
    /// otherwise.
    #[must_use]
    pub fn effective_log_refs_config(&self) -> refs::LogRefsConfig {
        match self.log_refs_config() {
            refs::LogRefsConfig::Unset if self.bool_or("core.bare", false) => {
                refs::LogRefsConfig::None
            }
            refs::LogRefsConfig::Unset => refs::LogRefsConfig::Normal,
            mode => mode,
        }
    }

    /// Build a set from already-parsed entries (in load order).
    pub(crate) fn from_entries(entries: Vec<ConfigEntry>) -> Self {
        Self { entries }
    }

    /// Get an integer value, supporting Git's `k`/`m`/`g` suffixes.
    ///
    /// # Returns
    ///
    /// `None` when `key` is unset, otherwise the parsed value.
    ///
    /// # Errors
    ///
    /// [`ConfigError::InvalidValue`] naming `key` when the value is not an integer or
    /// overflows `i64`.
    pub fn get_i64(&self, key: &str) -> Option<std::result::Result<i64, ConfigError>> {
        self.get(key)
            .map(|v| parse_i64(&v).map_err(|e| e.for_key(key)))
    }

    /// Parse `core.compression` / `core.looseCompression` style zlib level integers.
    ///
    /// `-1` selects zlib's default (level 6). Valid values are `-1` or `0..=9`; anything else
    /// is a configuration error.
    fn parse_zlib_compression_level(key: &str, raw: &str) -> Result<i32> {
        const Z_DEFAULT_COMPRESSION: i32 = 6;
        const Z_BEST_COMPRESSION: i32 = 9;

        let bad = |reason| {
            Error::Config(ConfigError::BadNumericValue {
                key: key.to_owned(),
                value: raw.to_owned(),
                reason,
            })
        };
        let v = parse_git_config_int_strict(raw.trim()).map_err(|e| bad(e.into()))?;
        if v == -1 {
            return Ok(Z_DEFAULT_COMPRESSION);
        }
        if v < 0 || v > i64::from(Z_BEST_COMPRESSION) {
            return Err(bad(BadNumericSource::OutOfRange));
        }
        Ok(v as i32)
    }

    /// Zlib deflate level for loose objects (Git's `zlib_compression_level`).
    ///
    /// Walks [`Self::entries`] in load order. Every `core.compression` and `core.looseCompression`
    /// entry is parsed and validated (including shadowed or overridden values); bare keys and
    /// invalid numbers return [`Error::Config`]. `core.compression` sets the loose level until
    /// the first valid `core.looseCompression` is seen; later `core.compression` entries are still
    /// validated but ignored for the loose level. When neither key appears, returns
    /// [`Self::LOOSE_OBJECTS_ZLIB_DEFAULT`] (`Z_BEST_SPEED`, level 1).
    ///
    /// `-1` means zlib default (level 6). Valid values are `-1` or `0..=9`.
    pub fn loose_objects_zlib_level(&self) -> Result<i32> {
        let mut loose_level = Self::LOOSE_OBJECTS_ZLIB_DEFAULT;
        let mut loose_compression_seen = false;
        let missing_value = |key: &str| {
            Error::Config(ConfigError::MissingValue {
                key: key.to_owned(),
            })
        };

        for e in self.entries() {
            match e.key.as_str() {
                "core.compression" => {
                    let val = e.value.as_deref().ok_or_else(|| missing_value(&e.key))?;
                    let level = Self::parse_zlib_compression_level(&e.key, val)?;
                    if !loose_compression_seen {
                        loose_level = level;
                    }
                }
                "core.loosecompression" => {
                    let val = e.value.as_deref().ok_or_else(|| missing_value(&e.key))?;
                    let level = Self::parse_zlib_compression_level(&e.key, val)?;
                    loose_level = level;
                    loose_compression_seen = true;
                }
                _ => {}
            }
        }

        Ok(loose_level)
    }

    /// Git's default zlib level for loose objects when neither `core.looseCompression` nor
    /// `core.compression` is set (`Z_BEST_SPEED`).
    pub const LOOSE_OBJECTS_ZLIB_DEFAULT: i32 = 1;

    /// Git's default `core.bigFileThreshold` (512 MiB).
    pub const BIG_FILE_THRESHOLD_DEFAULT: u64 = 512 * 1024 * 1024;

    /// Size in bytes at or above which files are treated as big (`core.bigFileThreshold`).
    ///
    /// Big files are hashed and stored as a stream instead of being read into memory, and
    /// are written straight into a pack. The value accepts Git's `k`/`m`/`g` suffixes; the
    /// last entry wins. When unset, returns [`Self::BIG_FILE_THRESHOLD_DEFAULT`].
    ///
    /// # Errors
    ///
    /// Returns [`ConfigError::BadNumericValue`] when the value is missing, not a number, has
    /// an unknown unit, or is negative.
    pub fn big_file_threshold(&self) -> Result<u64> {
        const KEY: &str = "core.bigfilethreshold";
        let Some(entry) = self.get_last_entry(KEY) else {
            return Ok(Self::BIG_FILE_THRESHOLD_DEFAULT);
        };
        let raw = entry.value.as_deref().unwrap_or_default();
        let bad = |reason| {
            Error::Config(ConfigError::BadNumericValue {
                key: KEY.to_owned(),
                value: raw.to_owned(),
                reason,
            })
        };
        let value = parse_git_config_int_strict(raw.trim()).map_err(|e| bad(e.into()))?;
        u64::try_from(value).map_err(|_| bad(BadNumericSource::OutOfRange))
    }

    /// Zlib deflate level for `git pack-objects` (Git's `pack_compression_level`).
    ///
    /// Entries are applied in [`Self::entries`] order. `core.compression` sets the pack level
    /// until a `pack.compression` appears (Git `pack_compression_seen`). `core.loosecompression`
    /// is ignored here — it only affects loose-object zlib, not packs.
    ///
    /// `-1` means zlib default (level 6). Valid values are `-1` or `0..=9`.
    pub fn pack_objects_zlib_level(&self) -> Result<i32> {
        const Z_DEFAULT_COMPRESSION: i32 = 6;

        // `core.loosecompression` affects loose objects only (Git `zlib_compression_level`), not pack.
        let mut pack_level = Z_DEFAULT_COMPRESSION;
        let mut pack_compression_seen = false;

        for e in self.entries() {
            match e.key.as_str() {
                "core.compression" => {
                    let Some(val) = e.value.as_deref() else {
                        continue;
                    };
                    let level = Self::parse_zlib_compression_level(&e.key, val)?;
                    if !pack_compression_seen {
                        pack_level = level;
                    }
                }
                "pack.compression" => {
                    let Some(val) = e.value.as_deref() else {
                        continue;
                    };
                    pack_level = Self::parse_zlib_compression_level(&e.key, val)?;
                    pack_compression_seen = true;
                }
                _ => {}
            }
        }

        Ok(pack_level)
    }

    /// Get all entries matching a key pattern (regex).
    ///
    /// Used by `git config --get-regexp`. Returns an error if the pattern
    /// is not a valid regex.
    pub fn get_regexp(&self, pattern: &str) -> std::result::Result<Vec<&ConfigEntry>, String> {
        let re = regex::Regex::new(pattern).map_err(|e| format!("invalid key pattern: {e}"))?;
        Ok(self
            .entries
            .iter()
            .filter(|e| re.is_match(&e.key))
            .collect())
    }

    /// Load the standard Git configuration file cascade for a repository.
    ///
    /// # Parameters
    ///
    /// - `git_dir` — path to the `.git` directory (for local/worktree config).
    /// - `include_system` — whether to load system config.
    ///
    /// # Errors
    ///
    /// Returns errors from file I/O or parsing.
    pub fn load(env: &Environment, git_dir: Option<&Path>, include_system: bool) -> Result<Self> {
        let opts = LoadConfigOptions {
            include_system,
            include_ctx: IncludeContext {
                git_dir: git_dir.map(PathBuf::from),
                cwd: env.cwd.clone(),
                pwd: env.pwd.clone(),
                env: std::sync::Arc::new(env.clone()),
                ..Default::default()
            },
            ..Default::default()
        };
        Self::load_with_options(env, git_dir, &opts)
    }

    /// Load the standard configuration cascade with explicit include and scope control.
    ///
    /// See [`LoadConfigOptions`] for `GIT_CONFIG_PARAMETERS` / `-c` include behaviour.
    ///
    /// Uncached load: parses the cascade from disk every call. Repository-scoped memoization
    /// lives on [`crate::repo_caches::RepoCaches::load_config_with_options`].
    pub fn load_with_options(
        env: &Environment,
        git_dir: Option<&Path>,
        opts: &LoadConfigOptions,
    ) -> Result<Self> {
        Self::load_with_options_uncached(env, git_dir, opts, &mut Vec::new())
    }

    fn read_local_config_text_optional(
        path: &Path,
        caches: Option<&std::sync::Arc<crate::repo_caches::RepoCaches>>,
    ) -> Result<Option<String>> {
        let read = |p: &Path| -> Result<Option<String>> {
            match fs::read_to_string(p) {
                Ok(text) => Ok(Some(text)),
                Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
                Err(e) => Err(Error::Io(e)),
            }
        };
        let Some(c) = caches else {
            return read(path);
        };
        match c.local_config_text(path) {
            Ok(text) => Ok(Some(text)),
            Err(Error::Io(e)) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
            Err(e) => Err(e),
        }
    }

    pub(crate) fn load_with_options_uncached(
        env: &Environment,
        git_dir: Option<&Path>,
        opts: &LoadConfigOptions,
        included_files: &mut Vec<PathBuf>,
    ) -> Result<Self> {
        let proc = opts.process_includes;
        let mut ctx = opts.include_ctx.clone();
        if ctx.cwd.as_os_str().is_empty() {
            ctx.cwd = env.cwd.clone();
        }
        ctx.pwd = env.pwd.clone();
        ctx.env = std::sync::Arc::new(env.clone());
        let mut layers = Vec::new();

        if opts.include_system && !git_config_nosystem_enabled(env) {
            let system_path = system_config_path(env);
            if let Some(f) = ConfigFile::from_path(&system_path, ConfigScope::System)? {
                layers.push(ConfigLayer::file(f));
            }
        }

        // Global config (Git merges every existing file: XDG then ~/.gitconfig).
        for path in global_config_paths(env) {
            if let Some(f) = ConfigFile::from_path(&path, ConfigScope::Global)? {
                layers.push(ConfigLayer::file(f));
            }
        }

        // Local config — linked worktrees read `commondir/config`, not the admin `config`.
        if let Some(gd) = git_dir {
            let common_dir = crate::repo::common_git_dir_for_config(gd);
            let local_path = common_dir.join("config");
            let local_text =
                Self::read_local_config_text_optional(&local_path, opts.repo_caches.as_ref())?;
            if let Some(msg) =
                crate::repo::early_config_ignore_repo_reason_for_text(local_text.as_deref())
            {
                if let Some(sink) = opts.diagnostics.as_ref() {
                    sink.warn(crate::diagnostics::Warning::IgnoredGitDir {
                        path: gd.to_path_buf(),
                        reason: msg,
                    });
                }
            } else if let Some(text) = local_text.as_deref() {
                let f = ConfigFile::parse(&local_path, text, ConfigScope::Local)?;
                layers.push(ConfigLayer::file(f));
            }

            // Worktree config — Git only reads `config.worktree` when
            // `extensions.worktreeConfig` is enabled in the common repository `config`.
            let wt_path = gd.join("config.worktree");
            if crate::repo::worktree_config_enabled_for_text(local_text.as_deref()) {
                if let Some(f) = ConfigFile::from_path(&wt_path, ConfigScope::Worktree)? {
                    layers.push(ConfigLayer::file(f));
                }
            }
        }

        if let Some(path) = env.git_config.as_deref() {
            let path = resolve_config_override_path(env, path);
            if let Some(f) = ConfigFile::from_path(&path, ConfigScope::Command)? {
                layers.push(ConfigLayer::file(f));
            }
        }

        layers.push(ConfigLayer::Entries(environment_config_pair_entries(env)?));

        // GIT_CONFIG_PARAMETERS — used by `git -c key=value`.
        if let Some(params) = env
            .git_config_parameters
            .as_deref()
            .filter(|p| !p.trim().is_empty())
        {
            if proc && opts.command_includes {
                let pseudo = Path::new(":GIT_CONFIG_PARAMETERS");
                let cmd_file = ConfigFile::from_git_config_parameters(pseudo, params)?;
                layers.push(ConfigLayer::file(cmd_file));
            } else {
                layers.push(ConfigLayer::Entries(command_override_entries(params)));
            }
        }

        let mut set = Self::new();
        set.merge_layers(&layers, proc, &ctx, included_files)?;
        Ok(set)
    }

    /// Read configuration the way Git's `read_early_config` / `do_git_config_sequence` does:
    /// system (unless disabled), global files in Git order, optional repository `config` /
    /// `config.worktree`, then `GIT_CONFIG_PARAMETERS`.
    ///
    /// When `git_dir` is `None` (no discovered repository, e.g. `GIT_CEILING_DIRECTORIES`), only
    /// non-repo layers are read — matching Git when discovery returns no gitdir (t1309 ceiling #2).
    ///
    /// Returns all values for `key` in load order (Git's `read_early_config` callback runs once per
    /// occurrence).
    ///
    /// This matches upstream ordering for `test-tool config read_early_config` (t1309, t1305).
    pub fn read_early_config(
        env: &Environment,
        git_dir: Option<&Path>,
        key: &str,
    ) -> Result<Vec<String>> {
        let ctx = IncludeContext {
            git_dir: git_dir.map(PathBuf::from),
            command_line_relative_include_is_error: false,
            cwd: env.cwd.clone(),
            pwd: env.pwd.clone(),
            env: std::sync::Arc::new(env.clone()),
        };
        let mut layers = Vec::new();

        if !git_config_nosystem_enabled(env) {
            let system_path = system_config_path(env);
            if let Ok(Some(f)) = ConfigFile::from_path(&system_path, ConfigScope::System) {
                layers.push(ConfigLayer::file(f));
            }
        }

        // Global: all existing candidates (Git merges every readable file).
        for path in global_config_paths(env) {
            if let Ok(Some(f)) = ConfigFile::from_path(&path, ConfigScope::Global) {
                layers.push(ConfigLayer::file(f));
            }
        }

        if let Some(gd) = git_dir {
            let common_dir = crate::repo::common_git_dir_for_config(gd);
            // Local (commondir) — skip when format is newer than supported (t1309).
            let local_path = common_dir.join("config");
            if crate::repo::early_config_ignore_repo_reason(&common_dir).is_some() {
                // Local config skipped for unsupported repository format (see `Warning::IgnoredGitDir`).
            } else if let Ok(Some(f)) = ConfigFile::from_path(&local_path, ConfigScope::Local) {
                layers.push(ConfigLayer::file(f));
            }

            // Worktree-specific config (when enabled for this repo).
            let wt_path = gd.join("config.worktree");
            if crate::repo::worktree_config_enabled(&common_dir) {
                if let Ok(Some(f)) = ConfigFile::from_path(&wt_path, ConfigScope::Worktree) {
                    layers.push(ConfigLayer::file(f));
                }
            }
        }

        // GIT_CONFIG_PARAMETERS — same as full load (`load_with_options` default).
        if let Some(params) = env
            .git_config_parameters
            .as_deref()
            .filter(|p| !p.trim().is_empty())
        {
            let pseudo = Path::new(":GIT_CONFIG_PARAMETERS");
            let cmd_file = ConfigFile::from_git_config_parameters(pseudo, params)?;
            layers.push(ConfigLayer::file(cmd_file));
        }

        let mut set = Self::new();
        set.merge_layers(&layers, true, &ctx, &mut Vec::new())?;
        Ok(set.get_all(key))
    }

    /// Merge a single config file, optionally expanding `[include]` / `[includeIf]`.
    ///
    /// Used by `grit config -f` and scoped reads; [`ConfigSet::load_with_options`] uses the same
    /// internal routine for the standard cascade.
    ///
    /// `hasconfig:remote.*.url:` conditions match only remote URLs reachable from `file`
    /// itself (like `git config -f <file> --includes`), not URLs already in `self`.
    ///
    /// # Errors
    ///
    /// Unreadable or unparsable include targets, include recursion past Git's depth limit,
    /// and [`ConfigError::RemoteUrlInHasconfigInclude`].
    pub fn merge_file_with_includes(
        &mut self,
        file: &ConfigFile,
        process_includes: bool,
        ctx: &IncludeContext,
    ) -> Result<()> {
        self.merge_layers(
            &[ConfigLayer::File(Cow::Borrowed(file))],
            process_includes,
            ctx,
            &mut Vec::new(),
        )
    }

    /// Load only the repository's own `config` file (plus any `[include]` targets).
    ///
    /// Unlike [`Self::load`], this ignores system/global config and environment
    /// overrides. Used for receive-side options (e.g. `transfer.fsckObjects`) so a
    /// pusher's global configuration cannot weaken the remote repository's policy.
    pub fn load_repo_local_only(git_dir: &Path) -> Result<Self> {
        let local_path = git_dir.join("config");
        let ctx = IncludeContext {
            git_dir: Some(git_dir.to_path_buf()),
            command_line_relative_include_is_error: false,
            cwd: PathBuf::from("."),
            pwd: None,
            env: std::sync::Arc::new(Environment::empty()),
        };
        let mut set = Self::new();
        if let Ok(Some(f)) = ConfigFile::from_path(&local_path, ConfigScope::Local) {
            set.merge_layers(&[ConfigLayer::file(f)], true, &ctx, &mut Vec::new())?;
        }
        Ok(set)
    }

    /// Load configuration the way Git loads **protected** config (e.g. `uploadpack.packObjectsHook`).
    ///
    /// This matches Git's `read_protected_config`: system (optional), global files only (no
    /// repository or worktree `config`), then command-line overrides from `GIT_CONFIG_COUNT` /
    /// `GIT_CONFIG_PARAMETERS`. It does **not** read `$GIT_CONFIG` (Git omits that for protected
    /// config).
    ///
    /// Global file order matches Git: XDG `git/config` first (when present), then `~/.gitconfig`,
    /// unless `GIT_CONFIG_GLOBAL` is set (single file). When both global files exist, both are
    /// merged so later entries win for duplicate keys.
    pub fn load_protected(env: &Environment, include_system: bool) -> Result<Self> {
        let ctx = IncludeContext {
            git_dir: None,
            command_line_relative_include_is_error: false,
            cwd: env.cwd.clone(),
            pwd: env.pwd.clone(),
            env: std::sync::Arc::new(env.clone()),
        };
        let mut layers = Vec::new();

        if include_system && !git_config_nosystem_enabled(env) {
            let system_path = system_config_path(env);
            if let Ok(Some(f)) = ConfigFile::from_path(&system_path, ConfigScope::System) {
                layers.push(ConfigLayer::file(f));
            }
        }

        for path in global_config_paths(env) {
            if let Ok(Some(f)) = ConfigFile::from_path(&path, ConfigScope::Global) {
                layers.push(ConfigLayer::file(f));
            }
        }

        layers.push(ConfigLayer::Entries(environment_config_pair_entries(env)?));
        if let Some(params) = env.git_config_parameters.as_deref() {
            layers.push(ConfigLayer::Entries(command_override_entries(params)));
        }

        let mut set = Self::new();
        set.merge_layers(&layers, true, &ctx, &mut Vec::new())?;
        Ok(set)
    }

    /// Merge `layers` in order, expanding includes in file layers when `process_includes`.
    ///
    /// `hasconfig:remote.*.url:` conditions anywhere in the load match against the remote
    /// URLs of *all* layers (Git evaluates them against the complete configuration), so a
    /// global include can depend on a remote defined in the repository `config`. Every
    /// include target opened is recorded in `included_files` so the cascade cache can stamp it.
    fn merge_layers(
        &mut self,
        layers: &[ConfigLayer<'_>],
        process_includes: bool,
        ctx: &IncludeContext,
        included_files: &mut Vec<PathBuf>,
    ) -> Result<()> {
        // Headroom for the entries of typical small include files (identities, aliases), so
        // merging one does not double a vector sized exactly to the top-level layers.
        const INCLUDE_HEADROOM: usize = 64;
        let mut remote_urls = RemoteUrls::new(layers);
        let top_level: usize = layers
            .iter()
            .map(|layer| match layer {
                ConfigLayer::File(file) => file.entries.len(),
                ConfigLayer::Entries(entries) => entries.len(),
            })
            .sum();
        self.entries.reserve(top_level + INCLUDE_HEADROOM);
        for layer in layers {
            match layer {
                ConfigLayer::File(file) => Self::merge_with_includes(
                    self,
                    file,
                    process_includes,
                    0,
                    ctx,
                    &mut remote_urls,
                    included_files,
                )?,
                ConfigLayer::Entries(entries) => self.entries.extend(entries.iter().cloned()),
            }
        }
        Ok(())
    }

    /// Merge `file`, expanding `[include]` / `[includeIf]` targets in place.
    fn merge_with_includes(
        set: &mut Self,
        file: &ConfigFile,
        process_includes: bool,
        depth: usize,
        ctx: &IncludeContext,
        remote_urls: &mut RemoteUrls<'_>,
        included_files: &mut Vec<PathBuf>,
    ) -> Result<()> {
        check_include_depth(depth)?;
        if !process_includes {
            set.merge(file);
            return Ok(());
        }

        for entry in &file.entries {
            set.entries.push(entry.clone());

            let Some((inc_path, condition)) = include_directive_for_entry(entry) else {
                continue;
            };
            if let Some(cond) = condition.as_deref() {
                let holds = match hasconfig_remote_url_pattern(cond) {
                    Some(pattern) => remote_urls.any_matches(pattern, ctx, included_files)?,
                    None => evaluate_include_condition(cond, file, ctx),
                };
                if !holds {
                    continue;
                }
            }
            let Some(inc_file) = open_include_target(&inc_path, file, ctx, included_files)? else {
                continue;
            };
            Self::merge_with_includes(
                set,
                &inc_file,
                process_includes,
                depth + 1,
                ctx,
                remote_urls,
                included_files,
            )?;
        }

        Ok(())
    }
}

/// One step of a configuration load, merged in order by [`ConfigSet::merge_layers`].
enum ConfigLayer<'a> {
    /// A config file whose includes are expanded when the load processes includes.
    File(Cow<'a, ConfigFile>),
    /// Entries appended verbatim (`GIT_CONFIG_COUNT` pairs, `-c` overrides read without includes).
    Entries(Vec<ConfigEntry>),
}

impl ConfigLayer<'_> {
    fn file(file: ConfigFile) -> Self {
        Self::File(Cow::Owned(file))
    }
}

/// Remote URLs that `hasconfig:remote.*.url:` conditions match against, collected from every
/// layer of the current load on the first such condition and reused for the rest of it.
struct RemoteUrls<'a> {
    layers: &'a [ConfigLayer<'a>],
    urls: Option<Vec<String>>,
}

impl<'a> RemoteUrls<'a> {
    fn new(layers: &'a [ConfigLayer<'a>]) -> Self {
        Self { layers, urls: None }
    }

    /// Whether any `remote.<name>.url` value in the load matches `pattern` (`WM_PATHNAME`).
    fn any_matches(
        &mut self,
        pattern: &str,
        ctx: &IncludeContext,
        included_files: &mut Vec<PathBuf>,
    ) -> Result<bool> {
        let urls = match self.urls.take() {
            Some(urls) => urls,
            None => self.collect(ctx, included_files)?,
        };
        let hit = urls
            .iter()
            .any(|url| wildmatch(pattern.as_bytes(), url.as_bytes(), WM_PATHNAME));
        self.urls = Some(urls);
        Ok(hit)
    }

    fn collect(
        &self,
        ctx: &IncludeContext,
        included_files: &mut Vec<PathBuf>,
    ) -> Result<Vec<String>> {
        let mut urls = Vec::new();
        for layer in self.layers {
            match layer {
                ConfigLayer::File(file) => {
                    collect_remote_urls(file, false, 0, ctx, &mut urls, included_files)?;
                }
                ConfigLayer::Entries(entries) => urls.extend(
                    entries
                        .iter()
                        .filter(|entry| is_remote_url_entry(entry))
                        .filter_map(|entry| entry.value.clone()),
                ),
            }
        }
        Ok(urls)
    }
}

/// Collect `remote.<name>.url` values from `file` and everything it includes.
///
/// As in Git, this pass opens every `[includeIf]` target whose condition holds, treating every
/// `hasconfig:remote.*.url:` condition as holding. Remote URLs may not come from a conditional
/// include (directly or through nested includes), since they could change which conditions hold:
/// finding one there is [`ConfigError::RemoteUrlInHasconfigInclude`].
fn collect_remote_urls(
    file: &ConfigFile,
    in_conditional_include: bool,
    depth: usize,
    ctx: &IncludeContext,
    urls: &mut Vec<String>,
    included_files: &mut Vec<PathBuf>,
) -> Result<()> {
    check_include_depth(depth)?;
    for entry in &file.entries {
        if is_remote_url_entry(entry) {
            if in_conditional_include {
                return Err(ConfigError::RemoteUrlInHasconfigInclude.into());
            }
            urls.extend(entry.value.clone());
            continue;
        }
        let Some((inc_path, condition)) = include_directive_for_entry(entry) else {
            continue;
        };
        let conditional = match condition.as_deref() {
            None => in_conditional_include,
            Some(cond) => {
                if hasconfig_remote_url_pattern(cond).is_none()
                    && !evaluate_include_condition(cond, file, ctx)
                {
                    continue;
                }
                true
            }
        };
        let Some(inc_file) = open_include_target(&inc_path, file, ctx, included_files)? else {
            continue;
        };
        collect_remote_urls(&inc_file, conditional, depth + 1, ctx, urls, included_files)?;
    }
    Ok(())
}

/// Fail once include nesting exceeds Git's limit, which stops runaway recursion.
fn check_include_depth(depth: usize) -> Result<()> {
    const MAX_INCLUDE_DEPTH: usize = 10;
    if depth > MAX_INCLUDE_DEPTH {
        return Err(ConfigError::IncludeDepthExceeded {
            depth,
            limit: MAX_INCLUDE_DEPTH,
        }
        .into());
    }
    Ok(())
}

/// Resolve and parse the target of an include directive in `file`, recording the resolved path
/// in `included_files` (even when missing) so the cascade cache stamps it.
///
/// Returns `None` for a missing target or a path Git skips. Parse errors in the target are
/// fatal, as in Git (t0001 `re-init reads matching includeIf.onbranch`).
fn open_include_target(
    inc_path: &str,
    file: &ConfigFile,
    ctx: &IncludeContext,
    included_files: &mut Vec<PathBuf>,
) -> Result<Option<ConfigFile>> {
    let Some(resolved) = resolve_include_file_path(inc_path, file, ctx)? else {
        return Ok(None);
    };
    included_files.push(resolved.clone());
    ConfigFile::from_path(&resolved, file.scope)
}

fn include_directive_for_entry(entry: &ConfigEntry) -> Option<(String, Option<String>)> {
    let val = entry.value.as_ref()?;
    if entry.key == "include.path" {
        return Some((val.clone(), None));
    }
    if entry.key.starts_with("includeif.") && entry.key.ends_with(".path") {
        let mid = &entry.key["includeif.".len()..entry.key.len() - ".path".len()];
        return Some((val.clone(), Some(mid.to_owned())));
    }
    None
}

// ── Process-lifetime config cascade cache ───────────────────────────
//
// `ConfigSet::load` / `load_with_options` are called per file in hot loops
// (grep/diff/add re-load the cascade for every path), so the parsed cascade
// is memoized for the lifetime of the process. A cached entry is served only
// when every input that fed it is provably unchanged:
//
// - the stat stamps (mtime + size, or "absent") of every base cascade file,
//   recorded *before* the parse, still match. `HEAD` is stamped too so that
//   `includeIf.onbranch:` condition flips invalidate;
// - every include target the parse resolved (even ones that were missing)
//   still carries the stamp it had at parse time;
// - the config-relevant environment is byte-identical.
//
// The remaining `includeIf` condition inputs are covered transitively:
// `gitdir:` depends only on the cache key and environment, and
// `hasconfig:remote.*.url:` depends only on the (stamped) file contents —
// every file its URL scan opens is recorded as an include target — plus the
// command-line config already in the environment fingerprint.
//
// In-process writers ([`ConfigFile::write`]) additionally evict every entry
// whose cascade contains the written path, closing the window where a
// rewrite lands within one mtime tick at an unchanged size. External writers
// in that same window are not detectable by stat; C git parses the cascade
// once per process with no revalidation at all, so serving a stamped copy is
// strictly more conservative than upstream.

/// Stat snapshot of one cascade file (`None` = file absent).
pub(crate) type ConfigFileStamp = (PathBuf, Option<(SystemTime, u64)>);

/// Stamp metadata stored with a memoized config cascade entry.
pub(crate) type ConfigCacheEntryStamps = (
    Vec<(String, Option<String>)>,
    Vec<ConfigFileStamp>,
    Vec<ConfigFileStamp>,
);

#[derive(Clone, PartialEq, Eq, Hash)]
pub(crate) struct ConfigCacheKey {
    pub(crate) git_dir: Option<PathBuf>,
    include_system: bool,
    process_includes: bool,
    command_includes: bool,
    ctx_git_dir: Option<PathBuf>,
    ctx_relative_include_is_error: bool,
}

impl ConfigCacheKey {
    pub fn new(git_dir: Option<&Path>, opts: &LoadConfigOptions) -> Self {
        Self {
            git_dir: git_dir.map(Path::to_path_buf),
            include_system: opts.include_system,
            process_includes: opts.process_includes,
            command_includes: opts.command_includes,
            ctx_git_dir: opts.include_ctx.git_dir.clone(),
            ctx_relative_include_is_error: opts.include_ctx.command_line_relative_include_is_error,
        }
    }
}

pub(crate) struct ConfigCacheEntry {
    pub(crate) env_fingerprint: Vec<(String, Option<String>)>,
    /// Stamps of the fixed cascade files (recomputable from key + env).
    pub(crate) base_stamps: Vec<ConfigFileStamp>,
    /// Stamps of the include targets this parse resolved (revalidated by
    /// re-statting each stored path).
    pub(crate) extra_stamps: Vec<ConfigFileStamp>,
    pub(crate) set: Arc<ConfigSet>,
}

/// The on-disk files [`ConfigSet::load_with_options_uncached`] would consult,
/// in cascade order.
fn config_cascade_file_paths(
    env: &Environment,
    git_dir: Option<&Path>,
    opts: &LoadConfigOptions,
) -> Vec<PathBuf> {
    let mut paths = Vec::new();
    if opts.include_system && !git_config_nosystem_enabled(env) {
        paths.push(system_config_path(env));
    }
    paths.extend(global_config_paths(env));
    if let Some(gd) = git_dir {
        let common_dir = crate::repo::common_git_dir_for_config(gd);
        paths.push(common_dir.join("config"));
        // Stamped unconditionally: whether it is merged depends on
        // `extensions.worktreeConfig` in the (stamped) common config.
        paths.push(gd.join("config.worktree"));
        // `includeIf.onbranch:` conditions read HEAD; stamping it means a
        // branch switch invalidates cascades that could depend on it.
        paths.push(gd.join("HEAD"));
    }
    if let Some(cgd) = &opts.include_ctx.git_dir {
        if Some(cgd.as_path()) != git_dir {
            paths.push(cgd.join("HEAD"));
        }
    }
    if let Some(p) = env.git_config.as_deref() {
        paths.push(resolve_config_override_path(env, p));
    }
    paths
}

pub(crate) fn stamp_for_path(path: &Path) -> Option<(SystemTime, u64)> {
    fs::metadata(path)
        .ok()
        .and_then(|m| Some((m.modified().ok()?, m.len())))
}

pub(crate) fn stamp_paths(paths: Vec<PathBuf>) -> Vec<ConfigFileStamp> {
    paths
        .into_iter()
        .map(|path| {
            let stamp = stamp_for_path(&path);
            (path, stamp)
        })
        .collect()
}

pub(crate) fn config_file_stamps(
    env: &Environment,
    git_dir: Option<&Path>,
    opts: &LoadConfigOptions,
) -> Vec<ConfigFileStamp> {
    stamp_paths(config_cascade_file_paths(env, git_dir, opts))
}

pub(crate) fn config_cache_lookup(
    cache: &HashMap<ConfigCacheKey, ConfigCacheEntry>,
    key: &ConfigCacheKey,
    env_fp: &[(String, Option<String>)],
    base_stamps: &[ConfigFileStamp],
) -> Option<Arc<ConfigSet>> {
    let entry = cache.get(key)?;
    if entry.env_fingerprint.as_slice() != env_fp || entry.base_stamps.as_slice() != base_stamps {
        return None;
    }
    for (path, stamp) in &entry.extra_stamps {
        if stamp_for_path(path) != *stamp {
            return None;
        }
    }
    Some(Arc::clone(&entry.set))
}

pub(crate) fn config_cache_store(
    cache: &mut HashMap<ConfigCacheKey, ConfigCacheEntry>,
    key: ConfigCacheKey,
    env_fingerprint: Vec<(String, Option<String>)>,
    base_stamps: Vec<ConfigFileStamp>,
    extra_stamps: Vec<ConfigFileStamp>,
    set: Arc<ConfigSet>,
) {
    cache.insert(
        key,
        ConfigCacheEntry {
            env_fingerprint,
            base_stamps,
            extra_stamps,
            set,
        },
    );
}

fn git_config_nosystem_enabled(env: &Environment) -> bool {
    env.git_config_nosystem
        .as_deref()
        .map(|value| parse_bool(value).unwrap_or(true))
        .unwrap_or(false)
}

/// Entries from `GIT_CONFIG_COUNT` / `GIT_CONFIG_KEY_<n>` / `GIT_CONFIG_VALUE_<n>`.
fn environment_config_pair_entries(env: &Environment) -> Result<Vec<ConfigEntry>> {
    let Some(count_str) = env.git_config_count.as_deref() else {
        return Ok(Vec::new());
    };
    if count_str.is_empty() {
        return Ok(Vec::new());
    }

    let count = count_str
        .parse::<usize>()
        .ok()
        .filter(|&n| n <= i32::MAX as usize)
        .ok_or_else(|| {
            Error::Config(ConfigError::InvalidEnvironmentCount {
                value: count_str.to_owned(),
            })
        })?;

    let mut set = ConfigSet::new();
    for i in 0..count {
        let (key, value) = env.git_config_pairs.get(i).ok_or(Error::Config(
            ConfigError::MissingEnvironmentKey { index: i },
        ))?;
        set.add_command_override(key, value)?;
    }
    Ok(set.entries)
}

/// `GIT_CONFIG_PARAMETERS` as plain command-scope entries (no include processing); entries
/// with an invalid key are skipped.
fn command_override_entries(params: &str) -> Vec<ConfigEntry> {
    let mut set = ConfigSet::new();
    for entry in parse_config_parameters(params) {
        let (key, val) = entry
            .split_once('\u{1}')
            .or_else(|| entry.split_once('='))
            .unwrap_or((entry.as_str(), "true"));
        let _ = set.add_command_override(key.trim(), val);
    }
    set.entries
}

// ── Type coercion helpers ───────────────────────────────────────────

/// Parse a Git boolean value.
///
/// Accepts: `true`, `yes`, `on`, `1` as true.
/// Accepts: `false`, `no`, `off`, `0` as false.
///
/// Note: bare config keys are represented as `None` in [`ConfigEntry`] and
/// are normalized to `"true"` by higher-level readers (`ConfigSet::get`).
/// An explicit empty assignment (`key =` with no value) is stored as `""` and
/// is treated as false for `--bool` / [`parse_bool`]. Bare keys are represented
/// as `None` and normalized to `"true"` by callers before reaching this parser.
///
/// # Errors
///
/// [`ConfigValueError::InvalidBool`] when `s` is neither a boolean word nor an integer.
pub fn parse_bool(s: &str) -> std::result::Result<bool, ConfigValueError> {
    match s.to_lowercase().as_str() {
        "true" | "yes" | "on" => Ok(true),
        "" => Ok(false),
        "false" | "no" | "off" => Ok(false),
        _ => parse_git_config_maybe_bool(s).ok_or_else(|| ConfigValueError::InvalidBool {
            value: s.to_owned(),
        }),
    }
}

/// Parse a Git integer value with optional `k`/`m`/`g` suffix.
///
/// # Errors
///
/// [`ConfigValueError::EmptyInteger`] for an empty value,
/// [`ConfigValueError::InvalidInteger`] when it is not a number, and
/// [`ConfigValueError::IntegerOverflow`] when the scaled value does not fit in `i64`.
pub fn parse_i64(s: &str) -> std::result::Result<i64, ConfigValueError> {
    let s = s.trim();
    if s.is_empty() {
        return Err(ConfigValueError::EmptyInteger);
    }

    let (num_str, multiplier) = match s.as_bytes().last() {
        Some(b'k' | b'K') => (&s[..s.len() - 1], 1024_i64),
        Some(b'm' | b'M') => (&s[..s.len() - 1], 1024 * 1024),
        Some(b'g' | b'G') => (&s[..s.len() - 1], 1024 * 1024 * 1024),
        _ => (s, 1_i64),
    };

    let base: i64 = num_str
        .parse()
        .map_err(|_| ConfigValueError::InvalidInteger {
            value: s.to_owned(),
        })?;
    base.checked_mul(multiplier)
        .ok_or_else(|| ConfigValueError::IntegerOverflow {
            value: s.to_owned(),
        })
}

/// Why [`parse_git_config_int_strict`] failed (mirrors Git `errno` after `git_parse_signed`).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum GitConfigIntStrictError {
    /// `EINVAL` — trailing junk, unknown unit suffix, or not a number.
    InvalidUnit,
    /// `ERANGE` — value does not fit in `i64` after scaling.
    OutOfRange,
}

/// Parse a signed decimal integer with optional `k`/`m`/`g` multiplier suffix, requiring the
/// entire input (trimmed) to be consumed — same constraints as Git's `git_parse_signed` used by
/// `git_config_int` (so `no` and `1foo` are rejected, unlike [`parse_i64`]).
pub fn parse_git_config_int_strict(raw: &str) -> std::result::Result<i64, GitConfigIntStrictError> {
    let s = raw.trim();
    if s.is_empty() {
        return Err(GitConfigIntStrictError::InvalidUnit);
    }

    let bytes = s.as_bytes();
    let mut idx = 0usize;
    if matches!(bytes.first(), Some(b'+') | Some(b'-')) {
        idx = 1;
    }
    if idx >= bytes.len() {
        return Err(GitConfigIntStrictError::InvalidUnit);
    }
    let digit_start = idx;
    while idx < bytes.len() && bytes[idx].is_ascii_digit() {
        idx += 1;
    }
    if idx == digit_start {
        return Err(GitConfigIntStrictError::InvalidUnit);
    }

    let num_part =
        std::str::from_utf8(&bytes[..idx]).map_err(|_| GitConfigIntStrictError::InvalidUnit)?;
    let suffix =
        std::str::from_utf8(&bytes[idx..]).map_err(|_| GitConfigIntStrictError::InvalidUnit)?;
    let mult: i64 = match suffix {
        "" => 1,
        "k" | "K" => 1024,
        "m" | "M" => 1024 * 1024,
        "g" | "G" => 1024_i64
            .checked_mul(1024)
            .and_then(|x| x.checked_mul(1024))
            .ok_or(GitConfigIntStrictError::OutOfRange)?,
        _ => return Err(GitConfigIntStrictError::InvalidUnit),
    };

    let val: i64 = num_part
        .parse()
        .map_err(|_| GitConfigIntStrictError::InvalidUnit)?;
    val.checked_mul(mult)
        .ok_or(GitConfigIntStrictError::OutOfRange)
}

fn is_c_locale_space(b: u8) -> bool {
    matches!(b, b' ' | b'\t' | b'\n' | b'\r' | 0x0b | 0x0c)
}

fn skip_c_locale_leading_whitespace(s: &str) -> &str {
    let bytes = s.as_bytes();
    let mut i = 0usize;
    while i < bytes.len() && is_c_locale_space(bytes[i]) {
        i += 1;
    }
    &s[i..]
}

fn git_unit_factor(suffix: &str) -> std::result::Result<i64, GitConfigIntStrictError> {
    match suffix {
        "" => Ok(1),
        "k" | "K" => Ok(1024),
        "m" | "M" => Ok(1024 * 1024),
        "g" | "G" => Ok(1024_i64 * 1024 * 1024),
        _ => Err(GitConfigIntStrictError::InvalidUnit),
    }
}

/// Parse a base-0 signed integer prefix (Git `strtoimax(..., 0)`), returning unconsumed suffix.
fn parse_base0_signed_prefix(s: &str) -> std::result::Result<(i64, &str), GitConfigIntStrictError> {
    let bytes = s.as_bytes();
    if bytes.is_empty() {
        return Err(GitConfigIntStrictError::InvalidUnit);
    }
    let mut i = 0usize;
    let mut sign: i64 = 1;
    if bytes[i] == b'+' {
        i += 1;
    } else if bytes[i] == b'-' {
        sign = -1;
        i += 1;
    }
    if i >= bytes.len() {
        return Err(GitConfigIntStrictError::InvalidUnit);
    }

    let base = if bytes[i] == b'0' {
        if i + 1 < bytes.len() && matches!(bytes[i + 1], b'x' | b'X') {
            i += 2;
            if i >= bytes.len() {
                return Err(GitConfigIntStrictError::InvalidUnit);
            }
            16
        } else {
            8
        }
    } else {
        10
    };

    let digit_start = i;
    let mut acc: i128 = 0;
    while i < bytes.len() {
        let ch = char::from(bytes[i]);
        let digit = match base {
            10 => ch.to_digit(10),
            8 => ch.to_digit(8),
            16 => ch.to_digit(16),
            _ => None,
        };
        let Some(d) = digit else {
            break;
        };
        acc = acc
            .checked_mul(base as i128)
            .and_then(|v| v.checked_add(i128::from(d)))
            .ok_or(GitConfigIntStrictError::OutOfRange)?;
        i += 1;
    }
    if i == digit_start {
        return Err(GitConfigIntStrictError::InvalidUnit);
    }

    let signed = if sign < 0 { -acc } else { acc };
    let val = i64::try_from(signed).map_err(|_| GitConfigIntStrictError::OutOfRange)?;
    Ok((val, &s[i..]))
}

/// Parse a signed integer with optional `k`/`m`/`g` scaling using Git base-0 rules (`git_parse_signed`).
pub fn parse_git_signed_config(
    raw: &str,
    max: i64,
) -> std::result::Result<i64, GitConfigIntStrictError> {
    if max < 0 {
        return Err(GitConfigIntStrictError::InvalidUnit);
    }
    let s = skip_c_locale_leading_whitespace(raw);
    if s.is_empty() {
        return Err(GitConfigIntStrictError::InvalidUnit);
    }

    let (val, rest) = parse_base0_signed_prefix(s)?;
    let factor = git_unit_factor(rest)?;

    if val < 0 {
        let min = -max - 1;
        if min / factor > val {
            return Err(GitConfigIntStrictError::OutOfRange);
        }
    } else if val > 0 && max / factor < val {
        return Err(GitConfigIntStrictError::OutOfRange);
    }

    val.checked_mul(factor)
        .ok_or(GitConfigIntStrictError::OutOfRange)
}

/// Parse a signed 32-bit config integer (`git_parse_int`).
pub fn parse_git_config_int(raw: &str) -> std::result::Result<i32, GitConfigIntStrictError> {
    let max = i32::MAX as i64;
    let n = parse_git_signed_config(raw, max)?;
    i32::try_from(n).map_err(|_| GitConfigIntStrictError::OutOfRange)
}

/// Parse Git `git_parse_maybe_bool`: `Some(true/false)` or `None` if unrecognized.
pub fn parse_git_config_maybe_bool(raw: &str) -> Option<bool> {
    if raw.is_empty() {
        return Some(false);
    }
    let lower = raw.to_ascii_lowercase();
    match lower.as_str() {
        "true" | "yes" | "on" => Some(true),
        "false" | "no" | "off" => Some(false),
        _ => parse_git_config_int(raw).ok().map(|n| n != 0),
    }
}

const DIFF_CONTEXT_KEY: &str = "diff.context";

/// Git's documented default for `gc.auto`.
const DEFAULT_GC_AUTO_THRESHOLD: usize = 6700;
/// Git's documented default for `gc.autoPackLimit`.
const DEFAULT_GC_AUTO_PACK_LIMIT: usize = 50;

fn bad_numeric_diff_context(
    value: &str,
    err: GitConfigIntStrictError,
    entry: &ConfigEntry,
) -> ConfigError {
    let reason = match err {
        GitConfigIntStrictError::InvalidUnit => crate::error::BadNumericSource::InvalidUnit,
        GitConfigIntStrictError::OutOfRange => crate::error::BadNumericSource::OutOfRange,
    };
    if entry.scope == ConfigScope::Command || entry.file.is_none() {
        ConfigError::BadNumericValue {
            key: DIFF_CONTEXT_KEY.to_owned(),
            value: value.to_owned(),
            reason,
        }
    } else {
        let path = entry
            .file
            .as_deref()
            .map(config_error_path_display)
            .unwrap_or_default();
        ConfigError::BadNumericValueInFile {
            key: DIFF_CONTEXT_KEY.to_owned(),
            value: value.to_owned(),
            file: path,
            reason,
        }
    }
}

fn bad_diff_context_variable(entry: &ConfigEntry) -> ConfigError {
    if entry.scope == ConfigScope::Command || entry.file.is_none() {
        ConfigError::UnableToParseFromCommandLine {
            key: DIFF_CONTEXT_KEY.to_owned(),
        }
    } else {
        let path = entry
            .file
            .as_deref()
            .map(config_error_path_display)
            .unwrap_or_default();
        ConfigError::BadConfigVariableAtLine {
            key: DIFF_CONTEXT_KEY.to_owned(),
            file: path,
            line: entry.line,
        }
    }
}

/// Read `diff.context` from a loaded [`ConfigSet`] with Git-compatible validation.
///
/// Returns `Ok(None)` when the key is unset. When set, the value must be a non-negative integer
/// acceptable to Git's diff machinery (same rules as `git diff` / `git log -p`).
pub fn resolve_diff_context_lines(cfg: &ConfigSet) -> Result<Option<usize>> {
    let Some(entry) = cfg.get_last_entry(DIFF_CONTEXT_KEY) else {
        return Ok(None);
    };
    let value_src = entry.value.as_deref().unwrap_or("").trim();
    match parse_git_config_int_strict(value_src) {
        Ok(n) if n < 0 => Err(bad_diff_context_variable(&entry).into()),
        Ok(n) => Ok(Some(usize::try_from(n).map_err(|_| {
            bad_numeric_diff_context(value_src, GitConfigIntStrictError::OutOfRange, &entry)
        })?)),
        Err(e) => Err(bad_numeric_diff_context(value_src, e, &entry).into()),
    }
}

/// Parse a Git color value and return the ANSI escape sequence.
///
/// Matches Git's `color_parse_mem` (`git/color.c`): whitespace-separated words,
/// optional leading `reset`, up to two color tokens (foreground then background),
/// then graphic rendition attributes. Attribute codes are accumulated as a
/// bitmask keyed by SGR number (so `bold` sets bit 1, `nobold` sets bit 22).
///
/// # Errors
///
/// [`ConfigValueError::InvalidColor`] when a word is neither a color nor an attribute, more
/// than two colors are given, or nothing usable is left.
pub fn parse_color(s: &str) -> std::result::Result<String, ConfigValueError> {
    const COLOR_BACKGROUND_OFFSET: i32 = 10;
    const COLOR_FOREGROUND_ANSI: i32 = 30;
    const COLOR_FOREGROUND_RGB: i32 = 38;
    const COLOR_FOREGROUND_256: i32 = 38;
    const COLOR_FOREGROUND_BRIGHT_ANSI: i32 = 90;

    #[derive(Clone, Copy, Default)]
    struct Color {
        kind: u8,
        value: u8,
        red: u8,
        green: u8,
        blue: u8,
    }

    const COLOR_UNSPECIFIED: u8 = 0;
    const COLOR_NORMAL: u8 = 1;
    const COLOR_ANSI: u8 = 2;
    const COLOR_256: u8 = 3;
    const COLOR_RGB: u8 = 4;

    fn color_empty(c: &Color) -> bool {
        c.kind == COLOR_UNSPECIFIED || c.kind == COLOR_NORMAL
    }

    fn parse_ansi_color(name: &str) -> Option<Color> {
        let color_names = [
            "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white",
        ];
        let color_offset = COLOR_FOREGROUND_ANSI;

        if name.eq_ignore_ascii_case("default") {
            return Some(Color {
                kind: COLOR_ANSI,
                value: (9 + color_offset) as u8,
                ..Default::default()
            });
        }

        let (name, color_offset) = if name.len() >= 6 && name[..6].eq_ignore_ascii_case("bright") {
            (&name[6..], COLOR_FOREGROUND_BRIGHT_ANSI)
        } else {
            (name, COLOR_FOREGROUND_ANSI)
        };

        for (i, cn) in color_names.iter().enumerate() {
            if name.eq_ignore_ascii_case(cn) {
                return Some(Color {
                    kind: COLOR_ANSI,
                    value: (i as i32 + color_offset) as u8,
                    ..Default::default()
                });
            }
        }
        None
    }

    fn hex_val(b: u8) -> Option<u8> {
        match b {
            b'0'..=b'9' => Some(b - b'0'),
            b'a'..=b'f' => Some(b - b'a' + 10),
            b'A'..=b'F' => Some(b - b'A' + 10),
            _ => None,
        }
    }

    fn get_hex_color(chars: &[u8], width: usize) -> Option<(u8, usize)> {
        assert!(width == 1 || width == 2);
        if chars.len() < width {
            return None;
        }
        let v = if width == 2 {
            let hi = hex_val(chars[0])?;
            let lo = hex_val(chars[1])?;
            (hi << 4) | lo
        } else {
            let n = hex_val(chars[0])?;
            (n << 4) | n
        };
        Some((v, width))
    }

    fn parse_single_color(word: &str) -> Option<Color> {
        if word.eq_ignore_ascii_case("normal") {
            return Some(Color {
                kind: COLOR_NORMAL,
                ..Default::default()
            });
        }

        let bytes = word.as_bytes();
        if (bytes.len() == 7 || bytes.len() == 4) && bytes.first() == Some(&b'#') {
            let width = if bytes.len() == 7 { 2 } else { 1 };
            let mut idx = 1;
            let (r, n1) = get_hex_color(&bytes[idx..], width)?;
            idx += n1;
            let (g, n2) = get_hex_color(&bytes[idx..], width)?;
            idx += n2;
            let (b, n3) = get_hex_color(&bytes[idx..], width)?;
            idx += n3;
            if idx != bytes.len() {
                return None;
            }
            return Some(Color {
                kind: COLOR_RGB,
                red: r,
                green: g,
                blue: b,
                ..Default::default()
            });
        }

        if let Some(c) = parse_ansi_color(word) {
            return Some(c);
        }

        let Ok(val) = word.parse::<i64>() else {
            return None;
        };
        if val < -1 {
            return None;
        }
        if val < 0 {
            return Some(Color {
                kind: COLOR_NORMAL,
                ..Default::default()
            });
        }
        if val < 8 {
            return Some(Color {
                kind: COLOR_ANSI,
                value: (val as i32 + COLOR_FOREGROUND_ANSI) as u8,
                ..Default::default()
            });
        }
        if val < 16 {
            return Some(Color {
                kind: COLOR_ANSI,
                value: (val as i32 - 8 + COLOR_FOREGROUND_BRIGHT_ANSI) as u8,
                ..Default::default()
            });
        }
        if val < 256 {
            return Some(Color {
                kind: COLOR_256,
                value: val as u8,
                ..Default::default()
            });
        }
        None
    }

    fn parse_attr(word: &str) -> Option<u8> {
        const ATTRS: [(&str, u8, u8); 8] = [
            ("bold", 1, 22),
            ("dim", 2, 22),
            ("italic", 3, 23),
            ("ul", 4, 24),
            ("underline", 4, 24),
            ("blink", 5, 25),
            ("reverse", 7, 27),
            ("strike", 9, 29),
        ];

        let mut negate = false;
        let mut rest = word;
        if let Some(stripped) = rest.strip_prefix("no") {
            negate = true;
            rest = stripped;
            if let Some(s) = rest.strip_prefix('-') {
                rest = s;
            }
        }

        for (name, val, neg) in ATTRS {
            if rest == name {
                return Some(if negate { neg } else { val });
            }
        }
        None
    }

    fn append_color_output(out: &mut String, c: &Color, background: bool) {
        let offset = if background {
            COLOR_BACKGROUND_OFFSET
        } else {
            0
        };
        match c.kind {
            COLOR_UNSPECIFIED | COLOR_NORMAL => {}
            COLOR_ANSI => {
                use std::fmt::Write;
                let _ = write!(out, "{}", i32::from(c.value) + offset);
            }
            COLOR_256 => {
                use std::fmt::Write;
                let _ = write!(out, "{};5;{}", COLOR_FOREGROUND_256 + offset, c.value);
            }
            COLOR_RGB => {
                use std::fmt::Write;
                let _ = write!(
                    out,
                    "{};2;{};{};{}",
                    COLOR_FOREGROUND_RGB + offset,
                    c.red,
                    c.green,
                    c.blue
                );
            }
            _ => {}
        }
    }

    let s = s.trim();
    let bad_color = || ConfigValueError::InvalidColor {
        value: s.to_owned(),
    };
    if s.is_empty() {
        return Ok(String::new());
    }

    let mut has_reset = false;
    let mut attr: u64 = 0;
    let mut fg = Color::default();
    let mut bg = Color::default();
    fg.kind = COLOR_UNSPECIFIED;
    bg.kind = COLOR_UNSPECIFIED;

    for word in s.split_whitespace() {
        if word.eq_ignore_ascii_case("reset") {
            has_reset = true;
            continue;
        }

        if let Some(c) = parse_single_color(word) {
            if fg.kind == COLOR_UNSPECIFIED {
                fg = c;
                continue;
            }
            if bg.kind == COLOR_UNSPECIFIED {
                bg = c;
                continue;
            }
            return Err(bad_color());
        }

        if let Some(code) = parse_attr(word) {
            attr |= 1u64 << u64::from(code);
            continue;
        }

        return Err(bad_color());
    }

    if !has_reset && attr == 0 && color_empty(&fg) && color_empty(&bg) {
        return Err(bad_color());
    }

    let mut out = String::from("\x1b[");
    let mut sep = if has_reset { 1u32 } else { 0u32 };

    let mut attr_bits = attr;
    let mut i = 0u32;
    while attr_bits != 0 {
        let bit = 1u64 << i;
        if attr_bits & bit == 0 {
            i += 1;
            continue;
        }
        attr_bits &= !bit;
        if sep > 0 {
            out.push(';');
        }
        sep += 1;
        use std::fmt::Write;
        let _ = write!(out, "{i}");
        i += 1;
    }

    if !color_empty(&fg) {
        if sep > 0 {
            out.push(';');
        }
        sep += 1;
        append_color_output(&mut out, &fg, false);
    }
    if !color_empty(&bg) {
        if sep > 0 {
            out.push(';');
        }
        append_color_output(&mut out, &bg, true);
    }
    out.push('m');
    Ok(out)
}

#[derive(Debug, Clone)]
struct UrlParts {
    scheme: String,
    user: Option<String>,
    host: String,
    port: Option<String>,
    path: String,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
struct UrlMatchScore {
    host_len: usize,
    path_len: usize,
    user_matched: bool,
}

fn parse_config_url(url: &str) -> Option<UrlParts> {
    let (scheme, rest) = url.split_once("://")?;
    let (authority, path) = match rest.find('/') {
        Some(idx) => (&rest[..idx], &rest[idx..]),
        None => (rest, "/"),
    };
    let (user, host_port) = match authority.rsplit_once('@') {
        Some((user, host)) => (Some(user.to_owned()), host),
        None => (None, authority),
    };
    let (host, port) = match host_port.rsplit_once(':') {
        Some((host, port)) if !host.contains(']') => (host, Some(port.to_owned())),
        _ => (host_port, None),
    };
    Some(UrlParts {
        scheme: scheme.to_lowercase(),
        user,
        host: host.to_lowercase(),
        port,
        path: if path.is_empty() {
            "/".to_owned()
        } else {
            path.trim_end_matches('/').to_owned()
        },
    })
}

fn host_matches(pattern: &str, target: &str) -> bool {
    let pattern_parts: Vec<&str> = pattern.split('.').collect();
    let target_parts: Vec<&str> = target.split('.').collect();
    pattern_parts.len() == target_parts.len()
        && pattern_parts
            .iter()
            .zip(target_parts)
            .all(|(pattern, target)| *pattern == "*" || *pattern == target)
}

fn path_match_len(pattern: &str, target: &str) -> Option<usize> {
    let pattern = if pattern.is_empty() { "/" } else { pattern };
    let target = if target.is_empty() { "/" } else { target };
    if pattern == "/" {
        return Some(1);
    }
    let pattern = pattern.trim_end_matches('/');
    if target == pattern
        || target
            .strip_prefix(pattern)
            .is_some_and(|rest| rest.starts_with('/'))
    {
        Some(pattern.len() + 1)
    } else {
        None
    }
}

fn url_match_score(pattern_url: &str, target_url: &str) -> Option<UrlMatchScore> {
    let pattern = parse_config_url(pattern_url)?;
    let target = parse_config_url(target_url)?;
    if pattern.scheme != target.scheme {
        return None;
    }
    let user_matched = match pattern.user.as_deref() {
        Some(user) if target.user.as_deref() == Some(user) => true,
        Some(_) => return None,
        None => false,
    };
    if !host_matches(&pattern.host, &target.host) || pattern.port != target.port {
        return None;
    }
    let path_len = path_match_len(&pattern.path, &target.path)?;
    Some(UrlMatchScore {
        host_len: pattern.host.len(),
        path_len,
        user_matched,
    })
}

/// Match a URL against a URL pattern from config.
pub fn url_matches(pattern_url: &str, target_url: &str) -> bool {
    url_match_score(pattern_url, target_url).is_some()
}

/// Get the best URL match for a specific key.
pub fn get_urlmatch_entries<'a>(
    entries: &'a [ConfigEntry],
    section: &str,
    variable: &str,
    url: &str,
) -> Vec<&'a ConfigEntry> {
    let section_lower = section.to_lowercase();
    let variable_lower = variable.to_lowercase();
    let mut matches: Vec<(UrlMatchScore, &'a ConfigEntry)> = Vec::new();

    for entry in entries {
        let key = &entry.key;
        let first_dot = match key.find('.') {
            Some(i) => i,
            None => continue,
        };
        let last_dot = match key.rfind('.') {
            Some(i) => i,
            None => continue,
        };
        let entry_section = &key[..first_dot];
        let entry_variable = &key[last_dot + 1..];
        if entry_section.to_lowercase() != section_lower
            || entry_variable.to_lowercase() != variable_lower
        {
            continue;
        }
        if first_dot == last_dot {
            matches.push((
                UrlMatchScore {
                    host_len: 0,
                    path_len: 0,
                    user_matched: false,
                },
                entry,
            ));
        } else {
            let subsection = &key[first_dot + 1..last_dot];
            if let Some(score) = url_match_score(subsection, url) {
                matches.push((score, entry));
            }
        }
    }
    matches.sort_by_key(|a| a.0);
    matches.into_iter().map(|(_, e)| e).collect()
}

/// Get all matching variables in a section for a given URL.
pub fn get_urlmatch_all_in_section(
    entries: &[ConfigEntry],
    section: &str,
    url: &str,
) -> Vec<(String, String, ConfigScope)> {
    let section_lower = section.to_lowercase();
    let mut matches: Vec<(String, UrlMatchScore, String, String, ConfigScope)> = Vec::new();

    for entry in entries {
        let key = &entry.key;
        let first_dot = match key.find('.') {
            Some(i) => i,
            None => continue,
        };
        let last_dot = match key.rfind('.') {
            Some(i) => i,
            None => continue,
        };
        let entry_section = &key[..first_dot];
        if entry_section.to_lowercase() != section_lower {
            continue;
        }
        let entry_variable = &key[last_dot + 1..];
        let val = entry.value.as_deref().unwrap_or("");
        if first_dot == last_dot {
            let canonical = format!("{}.{}", section_lower, entry_variable);
            matches.push((
                entry_variable.to_lowercase(),
                UrlMatchScore {
                    host_len: 0,
                    path_len: 0,
                    user_matched: false,
                },
                val.to_owned(),
                canonical,
                entry.scope,
            ));
        } else {
            let subsection = &key[first_dot + 1..last_dot];
            if let Some(score) = url_match_score(subsection, url) {
                let canonical = format!("{}.{}", section_lower, entry_variable);
                matches.push((
                    entry_variable.to_lowercase(),
                    score,
                    val.to_owned(),
                    canonical,
                    entry.scope,
                ));
            }
        }
    }

    let mut best: std::collections::BTreeMap<String, (UrlMatchScore, String, String, ConfigScope)> =
        std::collections::BTreeMap::new();
    for (var, specificity, val, canonical, scope) in matches {
        let entry = best.entry(var).or_insert((
            UrlMatchScore {
                host_len: 0,
                path_len: 0,
                user_matched: false,
            },
            String::new(),
            String::new(),
            scope,
        ));
        if specificity >= entry.0 {
            *entry = (specificity, val, canonical, scope);
        }
    }
    best.into_values()
        .map(|(_, val, canonical, scope)| (canonical, val, scope))
        .collect()
}

/// Parse a Git path value (expand `~/` to home directory).
/// Parse a path value. Returns the resolved path string.
/// Does NOT handle :(optional) prefix — use `parse_path_optional` for that.
pub fn parse_path(env: &Environment, s: &str) -> String {
    if let Some(rest) = s.strip_prefix("~/") {
        if let Some(home) = home_dir(env) {
            return home.join(rest).to_string_lossy().to_string();
        }
    }
    s.to_owned()
}

/// Parse a path value that may have an `:(optional)` prefix.
///
/// Returns `Some(path)` if the path should be used, `None` if the path
/// is optional and does not exist (meaning the entry should be skipped).
pub fn parse_path_optional(env: &Environment, s: &str) -> Option<String> {
    if let Some(rest) = s.strip_prefix(":(optional)") {
        let resolved = parse_path(env, rest);
        if std::path::Path::new(&resolved).exists() {
            Some(resolved)
        } else {
            None // optional and missing → skip
        }
    } else {
        Some(parse_path(env, s))
    }
}

// ── Helpers ─────────────────────────────────────────────────────────

/// Parse `GIT_CONFIG_PARAMETERS` payloads.
///
/// We support the common formats seen in tests and wrappers:
/// - single-quoted entries: `'key=value'`
/// - double-quoted entries: `"key=value"`
/// - unquoted `key=value` tokens separated by whitespace
///
/// Backslash escapes are interpreted minimally inside double quotes.
///
/// Return the last `key=value` assignment for `key` in a `GIT_CONFIG_PARAMETERS` payload.
///
/// Matches Git's command-line config layering: later tokens win. Keys are canonicalized the same
/// way as file-backed config (`fetch.output` and `FETCH.Output` both match `fetch.output`).
#[must_use]
pub fn git_config_parameters_last_value(raw: &str, key: &str) -> Option<String> {
    let Ok(canon) = canonical_key(key) else {
        return None;
    };
    let mut last: Option<String> = None;
    for entry in parse_config_parameters_strict(raw).ok()? {
        match entry {
            ConfigParameter::Pair { key, value } => {
                if canonical_key(key.trim()).ok().as_ref() == Some(&canon) {
                    last = Some(value.unwrap_or_else(|| "true".to_owned()));
                }
            }
            ConfigParameter::OldStyle(entry) => {
                if let Some((k, v)) = entry.split_once('=') {
                    if canonical_key(k.trim()).ok().as_ref() == Some(&canon) {
                        last = Some(v.to_owned());
                    }
                } else if canonical_key(entry.trim()).ok().as_ref() == Some(&canon) {
                    last = Some("true".to_owned());
                }
            }
        }
    }
    last
}

#[derive(Debug, Clone, PartialEq, Eq)]
enum ConfigParameter {
    OldStyle(String),
    Pair { key: String, value: Option<String> },
}

/// Parse `GIT_CONFIG_PARAMETERS` / `-c key=value` style parameter strings.
///
/// Returns Git's internal NUL-delimited representation used when bootstrapping config.
pub fn parse_config_parameters(raw: &str) -> Vec<String> {
    parse_config_parameters_strict(raw)
        .map(|entries| {
            entries
                .into_iter()
                .map(|entry| match entry {
                    ConfigParameter::OldStyle(entry) => entry,
                    ConfigParameter::Pair {
                        key,
                        value: Some(value),
                    } => format!("{key}\u{1}{value}"),
                    ConfigParameter::Pair { key, value: None } => format!("{key}\u{1}"),
                })
                .collect()
        })
        .unwrap_or_default()
}

fn parse_config_parameters_strict(raw: &str) -> Result<Vec<ConfigParameter>> {
    let mut out: Vec<ConfigParameter> = Vec::new();
    let chars: Vec<char> = raw.chars().collect();
    let mut idx = skip_config_parameter_spaces(&chars, 0);

    while idx < chars.len() {
        let (key, next) = sq_dequote_step_chars(&chars, idx)?;
        let Some(next_idx) = next else {
            out.push(ConfigParameter::OldStyle(key));
            break;
        };

        if chars[next_idx].is_whitespace() {
            out.push(ConfigParameter::OldStyle(key));
            idx = skip_config_parameter_spaces(&chars, next_idx);
            continue;
        }

        if chars[next_idx] != '=' {
            return Err(Error::Config(ConfigError::MalformedConfigParameters));
        }

        let value_start = next_idx + 1;
        if value_start >= chars.len() || chars[value_start].is_whitespace() {
            out.push(ConfigParameter::Pair { key, value: None });
            idx = skip_config_parameter_spaces(&chars, value_start);
            continue;
        }

        if chars[value_start] != '\'' {
            return Err(Error::Config(ConfigError::MalformedConfigParameters));
        }
        let (value, value_next) = sq_dequote_step_chars(&chars, value_start)?;
        if let Some(value_next) = value_next {
            if !chars[value_next].is_whitespace() {
                return Err(Error::Config(ConfigError::MalformedConfigParameters));
            }
            idx = skip_config_parameter_spaces(&chars, value_next);
        } else {
            idx = chars.len();
        }
        out.push(ConfigParameter::Pair {
            key,
            value: Some(value),
        });
    }

    Ok(out)
}

fn skip_config_parameter_spaces(chars: &[char], mut idx: usize) -> usize {
    while idx < chars.len() && chars[idx].is_whitespace() {
        idx += 1;
    }
    idx
}

fn sq_dequote_step_chars(chars: &[char], start: usize) -> Result<(String, Option<usize>)> {
    if chars.get(start) != Some(&'\'') {
        return Err(Error::Config(ConfigError::MalformedConfigParameters));
    }

    let mut out = String::new();
    let mut idx = start + 1;
    loop {
        let Some(&ch) = chars.get(idx) else {
            return Err(Error::Config(ConfigError::MalformedConfigParameters));
        };
        if ch != '\'' {
            out.push(ch);
            idx += 1;
            continue;
        }

        idx += 1;
        match chars.get(idx).copied() {
            None => return Ok((out, None)),
            Some('\\')
                if chars
                    .get(idx + 1)
                    .copied()
                    .is_some_and(needs_sq_backslash_quote)
                    && chars.get(idx + 2) == Some(&'\'') =>
            {
                if let Some(escaped) = chars.get(idx + 1) {
                    out.push(*escaped);
                }
                idx += 3;
            }
            _ => return Ok((out, Some(idx))),
        }
    }
}

fn needs_sq_backslash_quote(ch: char) -> bool {
    ch == '\'' || ch == '!'
}

/// Resolve a config file path from `GIT_CONFIG*` overrides relative to [`Environment::cwd`].
pub(crate) fn resolve_config_override_path(env: &Environment, path: &str) -> PathBuf {
    let p = Path::new(path);
    if p.is_absolute() {
        p.to_path_buf()
    } else {
        env.cwd.join(p)
    }
}

/// Return candidate paths for the global config file, in priority order.
/// Public accessor for the ordered list of global config file paths.
pub fn global_config_paths_pub(env: &Environment) -> Vec<PathBuf> {
    global_config_paths(env)
}

fn global_config_paths(env: &Environment) -> Vec<PathBuf> {
    let mut paths = Vec::new();

    // $GIT_CONFIG_GLOBAL overrides
    if let Some(p) = env.git_config_global.as_deref() {
        paths.push(resolve_config_override_path(env, p));
        return paths;
    }

    // Git order: XDG `git/config` first, then `~/.gitconfig` (see `git_global_config_paths`).
    if let Some(xdg) = env.xdg_config_home.as_deref() {
        paths.push(PathBuf::from(xdg).join("git/config"));
    } else if let Some(home) = home_dir(env) {
        paths.push(home.join(".config/git/config"));
    }
    if let Some(home) = home_dir(env) {
        paths.push(home.join(".gitconfig"));
    }

    paths
}

/// Path to the system-wide Git configuration file.
///
/// Honors `GIT_CONFIG_SYSTEM`. On Windows, falls back to Git for Windows'
/// `etc/gitconfig` when `/etc/gitconfig` is absent (stock shells, not MSYS).
#[must_use]
pub fn system_config_path(env: &Environment) -> PathBuf {
    if let Some(p) = env.git_config_system.as_deref() {
        return resolve_config_override_path(env, p);
    }
    let unix_default = PathBuf::from("/etc/gitconfig");
    #[cfg(windows)]
    {
        if unix_default.is_file() {
            return unix_default;
        }
        if let Some(root) = env.git_install_root.as_ref() {
            let candidate = PathBuf::from(root).join("etc").join("gitconfig");
            if candidate.is_file() {
                return candidate;
            }
        }
        for pf in [
            env.program_files.as_deref(),
            env.program_files_x86.as_deref(),
        ]
        .into_iter()
        .flatten()
        {
            let candidate = PathBuf::from(pf).join("Git").join("etc").join("gitconfig");
            if candidate.is_file() {
                return candidate;
            }
        }
    }
    unix_default
}

/// Return the user's home directory.
///
/// `$HOME` is honored on every platform. On Windows, where `$HOME` is usually
/// unset outside a Git-for-Windows/MSYS shell, we fall back to the same sources
/// Git does: `%HOMEDRIVE%%HOMEPATH%`, then `%USERPROFILE%`. Without this, global
/// config (`~/.gitconfig`) would be invisible on a stock Windows shell.
fn home_dir(env: &Environment) -> Option<PathBuf> {
    if let Some(home) = env.home.as_ref().filter(|h| !h.is_empty()) {
        return Some(PathBuf::from(home));
    }
    #[cfg(windows)]
    {
        if let (Some(drive), Some(path)) = (
            env.homedrive.as_ref().filter(|d| !d.is_empty()),
            env.homepath.as_ref().filter(|p| !p.is_empty()),
        ) {
            let mut combined = drive.clone();
            combined.push(path);
            return Some(PathBuf::from(combined));
        }
        if let Some(profile) = env.userprofile.as_ref().filter(|p| !p.is_empty()) {
            return Some(PathBuf::from(profile));
        }
    }
    None
}

/// True when Git would treat the config source as `CONFIG_ORIGIN_FILE` for includes.
fn include_source_is_disk_file(file: &ConfigFile) -> bool {
    file.include_origin == ConfigIncludeOrigin::Disk
}

/// Resolve an include file path (Git `handle_path_include` semantics).
///
/// Relative paths are only allowed when the including config came from a real on-disk file.
/// Returns `None` for a relative include from command-line config when the context allows
/// skipping it.
fn resolve_include_file_path(
    path: &str,
    file: &ConfigFile,
    ctx: &IncludeContext,
) -> Result<Option<PathBuf>> {
    let expanded = parse_path(ctx.env.as_ref(), path);
    let p = Path::new(&expanded);
    if p.is_absolute() {
        return Ok(Some(p.to_path_buf()));
    }
    if !include_source_is_disk_file(file) {
        if file.include_origin == ConfigIncludeOrigin::CommandLine
            && !ctx.command_line_relative_include_is_error
        {
            return Ok(None);
        }
        return Err(Error::Config(ConfigError::RelativeIncludeOutsideFile));
    }
    let base = match file.path.parent() {
        Some(p) if !p.as_os_str().is_empty() => p,
        Some(_) | None => Path::new("."),
    };
    Ok(Some(base.join(p)))
}

fn is_dir_sep(b: u8) -> bool {
    b == b'/' || b == b'\\'
}

fn add_trailing_starstar_for_dir(pat: &mut String) {
    let bytes = pat.as_bytes();
    if bytes.last().is_some_and(|&b| is_dir_sep(b)) {
        pat.push_str("**");
    }
}

/// Prepare a `gitdir:` / `gitdir/i:` pattern (Git `prepare_include_condition_pattern`).
///
/// Returns `None` when a relative (`./`) pattern cannot be anchored: the config did not come
/// from a file on disk, or its directory cannot be resolved.
fn prepare_gitdir_pattern(
    condition: &str,
    file: &ConfigFile,
    ctx: &IncludeContext,
) -> Option<(String, usize)> {
    // Git `interpolate_path`: expand `~/` in the condition before pattern rules.
    let mut pat = parse_path(ctx.env.as_ref(), condition);
    if pat.starts_with("./") || pat.starts_with(".\\") {
        let parent = file
            .path
            .parent()
            .filter(|_| include_source_is_disk_file(file))?;
        let real = parent.canonicalize_simplified().ok()?;
        let mut dir = real.to_string_lossy().into_owned();
        if !dir.ends_with('/') && !dir.ends_with('\\') {
            dir.push('/');
        }
        let rest = &pat[2..];
        pat = format!("{dir}{rest}");
        let prefix_len = dir.len();
        add_trailing_starstar_for_dir(&mut pat);
        return Some((pat, prefix_len));
    }
    let p = Path::new(&pat);
    if !p.is_absolute() {
        pat.insert_str(0, "**/");
    }
    add_trailing_starstar_for_dir(&mut pat);
    Some((pat, 0))
}

/// Git `include_by_gitdir` tries `strbuf_realpath` first, then `strbuf_add_absolute_path` if no match.
///
/// `text_abs` uses `$PWD` (which preserves symlinks) when available, matching Git's
/// `strbuf_add_absolute_path` behaviour. This lets `gitdir:bar/` match when `bar` is a symlink.
fn git_dir_match_texts(ctx: &IncludeContext, git_dir: &Path) -> (String, String) {
    let real = git_dir
        .canonicalize_simplified()
        .map(|p| p.to_string_lossy().into_owned())
        .unwrap_or_else(|_| git_dir.to_string_lossy().into_owned());
    // Build the non-canonical absolute path using $PWD (symlink-preserving) when available.
    // Git C uses `strbuf_add_absolute_path` which prefers $PWD over getcwd() to preserve symlinks.
    let abs = if git_dir.is_absolute() {
        // If git_dir is already canonical, try to reconstruct the symlink-preserving variant
        // by replacing the canonical cwd prefix with $PWD.
        let pwd_abs = ctx.pwd.as_deref().and_then(|pwd| {
            let pwd_path = std::path::Path::new(pwd);
            if !pwd_path.is_absolute() {
                return None;
            }
            let pwd_canon = pwd_path.canonicalize_simplified().ok()?;
            let git_dir_str = git_dir.to_string_lossy();
            let pwd_canon_str = pwd_canon.to_string_lossy();
            // If git_dir starts with the canonical cwd, replace that prefix with $PWD
            let suffix = git_dir_str.strip_prefix(pwd_canon_str.as_ref())?;
            Some(format!("{pwd}{suffix}"))
        });
        pwd_abs.unwrap_or_else(|| git_dir.to_string_lossy().into_owned())
    } else {
        ctx.cwd.join(git_dir).to_string_lossy().into_owned()
    };
    (real, abs)
}

fn include_by_gitdir(
    condition: &str,
    file: &ConfigFile,
    ctx: &IncludeContext,
    icase: bool,
) -> bool {
    let Some(git_dir) = ctx.git_dir.as_ref() else {
        return false;
    };
    let Some((pattern, prefix)) = prepare_gitdir_pattern(condition, file, ctx) else {
        return false;
    };
    let flags = WM_PATHNAME | if icase { WM_CASEFOLD } else { 0 };
    let (text_real, text_abs) = git_dir_match_texts(ctx, git_dir);
    let try_match = |text: &str| -> bool {
        let t = text.as_bytes();
        let p = pattern.as_bytes();
        if prefix > 0 {
            if t.len() < prefix {
                return false;
            }
            let pre = &p[..prefix];
            let te = &t[..prefix];
            let ok = if icase {
                pre.eq_ignore_ascii_case(te)
            } else {
                pre == te
            };
            if !ok {
                return false;
            }
            return wildmatch(&p[prefix..], &t[prefix..], flags);
        }
        wildmatch(p, t, flags)
    };
    if try_match(&text_real) {
        return true;
    }
    text_real != text_abs && try_match(&text_abs)
}

fn current_branch_short_name(git_dir: Option<&Path>) -> Option<String> {
    let gd = git_dir?;
    let target = refs::read_symbolic_ref(gd, "HEAD").ok()??;
    let rest = target.strip_prefix("refs/heads/")?;
    Some(rest.to_owned())
}

fn include_by_onbranch(condition: &str, ctx: &IncludeContext) -> bool {
    let Some(short) = current_branch_short_name(ctx.git_dir.as_deref()) else {
        return false;
    };
    let mut pattern = condition.to_owned();
    add_trailing_starstar_for_dir(&mut pattern);
    wildmatch(pattern.as_bytes(), short.as_bytes(), WM_PATHNAME)
}

/// Whether `entry` is `remote.<name>.url` (keys are canonical: section and variable lowercase).
fn is_remote_url_entry(entry: &ConfigEntry) -> bool {
    entry
        .key
        .strip_prefix("remote.")
        .is_some_and(|rest| rest.ends_with(".url"))
}

/// The URL glob of a `hasconfig:remote.*.url:<glob>` include condition.
fn hasconfig_remote_url_pattern(condition: &str) -> Option<&str> {
    condition.strip_prefix("hasconfig:remote.*.url:")
}

/// Evaluate an `[includeIf]` condition.
///
/// Supports `gitdir:`, `gitdir/i:` and `onbranch:` like Git. `hasconfig:remote.*.url:` needs
/// the whole load's remote URLs and is evaluated by [`RemoteUrls::any_matches`]. Unknown
/// prefixes are false.
fn evaluate_include_condition(condition: &str, file: &ConfigFile, ctx: &IncludeContext) -> bool {
    if let Some(rest) = condition.strip_prefix("gitdir/i:") {
        return include_by_gitdir(rest, file, ctx, true);
    }
    if let Some(rest) = condition.strip_prefix("gitdir:") {
        return include_by_gitdir(rest, file, ctx, false);
    }
    if let Some(rest) = condition.strip_prefix("onbranch:") {
        return include_by_onbranch(rest, ctx);
    }
    false
}

/// Split a canonical key into (section, subsection, variable).
fn split_key(key: &str) -> Result<(String, Option<String>, String)> {
    let (Some(first_dot), Some(last_dot)) = (key.find('.'), key.rfind('.')) else {
        return Err(Error::Config(ConfigError::InvalidKey {
            key: key.to_owned(),
            reason: InvalidKeyReason::MissingSection,
        }));
    };

    let section = key[..first_dot].to_owned();
    let variable = key[last_dot + 1..].to_owned();

    let subsection = if first_dot == last_dot {
        None
    } else {
        Some(key[first_dot + 1..last_dot].to_owned())
    };

    Ok((section, subsection, variable))
}

/// Parse a section name that may contain a subsection (e.g. `"remote.origin"`).
///
/// Returns (section, subsection).
fn parse_section_name(name: &str) -> (&str, Option<&str>) {
    match name.find('.') {
        Some(i) => (&name[..i], Some(&name[i + 1..])),
        None => (name, None),
    }
}

fn section_matches(parser: &Parser, section_lower: &str, subsection: Option<&str>) -> bool {
    if parser.section.to_lowercase() == section_lower && parser.subsection.as_deref() == subsection
    {
        return true;
    }
    let Some(subsection) = subsection else {
        return false;
    };
    parser.subsection.is_none()
        && parser.section.to_lowercase() == format!("{section_lower}.{}", subsection.to_lowercase())
}

/// Path to the lock file Git uses when updating a config file (`config.lock`).
#[must_use]
pub fn config_lock_path(path: &Path) -> PathBuf {
    let file_name = path
        .file_name()
        .and_then(|s| s.to_str())
        .unwrap_or("config");
    path.with_file_name(format!("{file_name}.lock"))
}

/// Reject a section name whose section part is not ASCII letters, digits and `-`, or whose
/// subsection is present but empty. `name` is the caller's full input, kept for the error.
fn validate_section_name(name: &str, section: &str, subsection: Option<&str>) -> Result<()> {
    if section.is_empty()
        || !section
            .chars()
            .all(|ch| ch.is_ascii_alphanumeric() || ch == '-')
        || subsection.is_some_and(str::is_empty)
    {
        return Err(Error::Config(ConfigError::InvalidSectionName {
            section: name.to_owned(),
        }));
    }
    Ok(())
}

/// Extract the original-case variable name from a raw (user-typed) key.
///
/// E.g. `"Section.Movie"` → `"Movie"`, `"a.b.CamelCase"` → `"CamelCase"`.
fn raw_variable_name(raw_key: &str) -> &str {
    match raw_key.rfind('.') {
        Some(i) => &raw_key[i + 1..],
        None => raw_key,
    }
}

/// Extract the original-case section and subsection from a raw (user-typed) key.
///
/// E.g. `"Section.key"` → `("Section", None)`,
///      `"Remote.origin.url"` → `("Remote", Some("origin"))`.
fn raw_section_parts(raw_key: &str) -> (String, Option<String>) {
    let first_dot = match raw_key.find('.') {
        Some(i) => i,
        None => return (raw_key.to_owned(), None),
    };
    // rfind always succeeds here since we already found at least one dot above.
    let last_dot = match raw_key.rfind('.') {
        Some(i) => i,
        None => return (raw_key[..first_dot].to_owned(), None),
    };
    let section = raw_key[..first_dot].to_owned();
    if first_dot == last_dot {
        (section, None)
    } else {
        let subsection = raw_key[first_dot + 1..last_dot].to_owned();
        (section, Some(subsection))
    }
}

/// Check if a raw line is a section header that also contains an inline key=value.
fn is_section_header_with_inline_entry(line: &str) -> bool {
    let trimmed = line.trim();
    if !trimmed.starts_with('[') {
        return false;
    }
    let end = match trimmed.find(']') {
        Some(i) => i,
        None => return false,
    };
    let after = trimmed[end + 1..].trim();
    // Has non-comment content after the ]
    !after.is_empty() && !after.starts_with('#') && !after.starts_with(';')
}

/// Extract just the section header portion (up to and including `]` and any
/// comment after it, but not any inline key=value) from a raw line.
fn extract_section_header(line: &str) -> String {
    let trimmed = line.trim();
    let end = match trimmed.find(']') {
        Some(i) => i,
        None => return line.to_owned(),
    };
    // Preserve any comment on the section header itself (between ] and key),
    // but git doesn't really do this. Just return up to ].
    trimmed[..=end].to_owned()
}

#[cfg(test)]
mod pack_object_config_tests {
    use super::{ConfigFile, ConfigScope, ConfigSet};
    use std::path::Path;

    fn set_from_snippet(text: &str) -> ConfigSet {
        let path = Path::new(".git/config");
        let file = ConfigFile::parse(path, text, ConfigScope::Local).expect("parse config snippet");
        let mut set = ConfigSet::new();
        set.merge(&file);
        set
    }

    #[test]
    fn pack_object_window_and_depth_defaults() {
        let set = ConfigSet::new();
        assert_eq!(set.pack_object_window(), 10);
        assert_eq!(set.pack_object_depth(), crate::pack::DEFAULT_PACK_DEPTH);
    }

    #[test]
    fn pack_object_window_and_depth_preserve_explicit_zero() {
        let set = set_from_snippet("[pack]\n\twindow = 0\n\tdepth = 0\n");
        assert_eq!(set.pack_object_window(), 0);
        assert_eq!(set.pack_object_depth(), 0);
    }

    #[test]
    fn gc_auto_limits_from_config() {
        let set = set_from_snippet("[gc]\n\tauto = 100\n\tautoPackLimit = 3\n");
        assert_eq!(set.gc_auto_threshold(), Some(100));
        assert_eq!(set.gc_auto_pack_limit(), Some(3));
        let defaults = ConfigSet::new();
        assert_eq!(defaults.gc_auto_threshold(), Some(6700));
        assert_eq!(defaults.gc_auto_pack_limit(), Some(50));
        assert!(defaults.gc_auto_detach());
        assert!(defaults.maintenance_auto());
        let disabled = set_from_snippet("[gc]\n\tautoPackLimit = 0\n");
        assert_eq!(disabled.gc_auto_pack_limit(), None);
        assert_eq!(disabled.gc_auto_threshold(), Some(6700));
        let auto_off = set_from_snippet("[gc]\n\tauto = 0\n");
        assert_eq!(auto_off.gc_auto_threshold(), None);
        let negative = set_from_snippet("[gc]\n\tauto = -1\n\tautoPackLimit = -1\n");
        assert_eq!(negative.gc_auto_threshold(), None);
        assert_eq!(negative.gc_auto_pack_limit(), None);
        let unparsable = set_from_snippet("[gc]\n\tauto = lots\n");
        assert_eq!(unparsable.gc_auto_threshold(), Some(6700));
        let foreground =
            set_from_snippet("[gc]\n\tautoDetach = false\n[maintenance]\n\tauto = false\n");
        assert!(!foreground.gc_auto_detach());
        assert!(!foreground.maintenance_auto());
    }
}

#[cfg(test)]
mod value_error_tests {
    use super::{parse_bool, parse_color, parse_i64, ConfigFile, ConfigScope, ConfigSet};
    use crate::error::{ConfigError, ConfigValueError, Error};
    use std::path::Path;

    fn set_from_snippet(text: &str) -> ConfigSet {
        let file = ConfigFile::parse(Path::new(".git/config"), text, ConfigScope::Local)
            .expect("parse config snippet");
        let mut set = ConfigSet::new();
        set.merge(&file);
        set
    }

    #[test]
    fn parse_bool_rejects_non_boolean_with_the_value() {
        assert_eq!(
            parse_bool("maybe"),
            Err(ConfigValueError::InvalidBool {
                value: "maybe".to_owned()
            })
        );
        assert_eq!(parse_bool("2"), Ok(true));
        assert_eq!(parse_bool(""), Ok(false));
    }

    #[test]
    fn parse_i64_distinguishes_empty_invalid_and_overflow() {
        assert_eq!(parse_i64("  "), Err(ConfigValueError::EmptyInteger));
        assert_eq!(
            parse_i64(" 12x "),
            Err(ConfigValueError::InvalidInteger {
                value: "12x".to_owned()
            })
        );
        assert_eq!(
            parse_i64("9223372036854775807k"),
            Err(ConfigValueError::IntegerOverflow {
                value: "9223372036854775807k".to_owned()
            })
        );
        assert_eq!(parse_i64("2m"), Ok(2 * 1024 * 1024));
    }

    #[test]
    fn parse_color_reports_the_trimmed_value() {
        let bad = ConfigValueError::InvalidColor {
            value: "red green blue".to_owned(),
        };
        assert_eq!(parse_color(" red green blue "), Err(bad));
        assert_eq!(
            parse_color("nonsense").map_err(|e| e.to_string()),
            Err("bad color value 'nonsense'".to_owned())
        );
        assert_eq!(parse_color("  "), Ok(String::new()));
    }

    #[test]
    fn get_bool_and_get_i64_name_the_key() {
        let set = set_from_snippet("[core]\n\tbare = sometimes\n[pack]\n\tthreads = many\n");
        let bool_err = set
            .get_bool("core.bare")
            .and_then(Result::err)
            .expect("invalid bool");
        assert_eq!(
            bool_err,
            ConfigError::InvalidValue {
                key: "core.bare".to_owned(),
                source: ConfigValueError::InvalidBool {
                    value: "sometimes".to_owned()
                },
            }
        );
        assert_eq!(
            bool_err.to_string(),
            "bad boolean config value 'sometimes' for 'core.bare'"
        );
        let int_err = set
            .get_i64("pack.threads")
            .and_then(Result::err)
            .expect("invalid int");
        assert!(matches!(
            &int_err,
            ConfigError::InvalidValue { key, source: ConfigValueError::InvalidInteger { value } }
                if key == "pack.threads" && value == "many"
        ));
        assert!(matches!(Error::from(int_err), Error::Config(_)));
        assert!(set.get_bool("core.missing").is_none());
    }

    #[test]
    fn typed_readers_match_any_casing_of_the_key() {
        let set = set_from_snippet(
            "[CORE]\n\tQUOTEPATH = false\n[pack]\n\twritebitmaphashcache = false\n\tREADREVERSEINDEX = false\n",
        );
        assert!(!set.quote_path_fully());
        assert!(!set.pack_write_bitmap_hash_cache());
        assert!(!set.pack_read_reverse_index_default());
        assert_eq!(set.get_bool("Core.QuotePath"), Some(Ok(false)));
    }

    #[test]
    fn bool_or_uses_the_default_only_when_unset_or_invalid() {
        let set = set_from_snippet(
            "[core]\n\tbare = sometimes\n\tlogAllRefUpdates\n[feature]\n\tmanyFiles = off\n",
        );
        for default in [false, true] {
            assert_eq!(set.bool_or("core.missing", default), default);
            assert_eq!(set.bool_or("core.bare", default), default);
            assert!(set.bool_or("core.logallrefupdates", default));
            assert!(!set.bool_or("FEATURE.MANYFILES", default));
        }
    }

    #[test]
    fn core_bool_accessors_use_git_defaults() {
        let unset = set_from_snippet("");
        assert!(!unset.ignore_case());
        assert!(!unset.precompose_unicode());
        assert!(unset.preload_index());
        assert!(unset.file_mode());

        let flipped = set_from_snippet(
            "[core]\n\tignorecase = true\n\tprecomposeunicode = yes\n\tpreloadindex = 0\n\tfilemode = off\n",
        );
        assert!(flipped.ignore_case());
        assert!(flipped.precompose_unicode());
        assert!(!flipped.preload_index());
        assert!(!flipped.file_mode());

        let invalid = set_from_snippet(
            "[core]\n\tignoreCase = maybe\n\tprecomposeUnicode = maybe\n\tpreloadIndex = maybe\n\tfileMode = maybe\n",
        );
        assert!(!invalid.ignore_case());
        assert!(!invalid.precompose_unicode());
        assert!(invalid.preload_index());
        assert!(invalid.file_mode());
    }

    #[test]
    fn for_key_keeps_the_source_error() {
        let err = ConfigValueError::EmptyInteger.for_key("gc.auto");
        assert_eq!(err.to_string(), "empty integer value for 'gc.auto'");
        let source = std::error::Error::source(&err).map(ToString::to_string);
        assert_eq!(source.as_deref(), Some("empty integer value"));
    }
}

#[cfg(test)]
mod get_regexp_tests {
    use super::{ConfigFile, ConfigScope, ConfigSet};
    use std::path::Path;

    fn set_from_snippet(text: &str) -> ConfigSet {
        let path = Path::new(".git/config");
        let file = ConfigFile::parse(path, text, ConfigScope::Local).expect("parse config snippet");
        let mut set = ConfigSet::new();
        set.merge(&file);
        set
    }

    #[test]
    fn get_regexp_matches_section_prefix_like_git_config() {
        let text = r#"
[user]
    email = alice@example.com
    name = Alice
[core]
    bare = false
"#;
        let set = set_from_snippet(text);
        let keys: Vec<_> = set
            .get_regexp("user")
            .expect("valid pattern")
            .into_iter()
            .map(|e| e.key.as_str())
            .collect();
        assert!(keys.contains(&"user.email"));
        assert!(keys.contains(&"user.name"));
        assert!(!keys.iter().any(|k| k.starts_with("core.")));
    }

    #[test]
    fn get_regexp_returns_all_multi_value_entries_in_order() {
        let text = r#"
[remote "origin"]
    url = https://example.com/repo.git
    fetch = +refs/heads/*:refs/remotes/origin/*
    push = +refs/heads/main:refs/heads/main
    push = +refs/heads/develop:refs/heads/develop
"#;
        let set = set_from_snippet(text);
        let matches = set.get_regexp("remote.origin").expect("valid pattern");
        let push_vals: Vec<_> = matches
            .iter()
            .filter(|e| e.key == "remote.origin.push")
            .map(|e| e.value.as_deref().unwrap_or(""))
            .collect();
        assert_eq!(push_vals.len(), 2);
        assert_eq!(push_vals[0], "+refs/heads/main:refs/heads/main");
        assert_eq!(push_vals[1], "+refs/heads/develop:refs/heads/develop");
    }

    #[test]
    fn get_regexp_dot_matches_any_key() {
        let text = r#"
[a]
    x = 1
[b]
    y = 2
"#;
        let set = set_from_snippet(text);
        let m = set.get_regexp(".").expect("valid pattern");
        assert_eq!(m.len(), 2);
    }

    #[test]
    fn get_regexp_no_match_returns_empty_vec() {
        let set = set_from_snippet("[user]\n\tname = x\n");
        let m = set.get_regexp("zzz").expect("valid pattern");
        assert!(m.is_empty());
    }

    #[test]
    fn get_regexp_invalid_pattern_is_error() {
        let set = set_from_snippet("[user]\n\tname = x\n");
        let err = set.get_regexp("(").expect_err("unclosed group");
        assert!(err.contains("invalid key pattern"), "got: {err}");
    }

    #[test]
    fn valueless_negotiation_algorithm_is_a_typed_config_error() {
        use crate::error::{ConfigError, Error};

        let path = Path::new("/repo/.git/config");
        for (text, line) in [
            (
                "[core]\n\tbare = false\n[fetch]\n\tnegotiationAlgorithm\n",
                4,
            ),
            ("[fetch] negotiationAlgorithm\n", 1),
        ] {
            let err = ConfigFile::parse(path, text, ConfigScope::Local).expect_err(text);
            let Error::Config(config_err) = err else {
                panic!("expected a config error for {text:?}, got {err:?}");
            };
            assert_eq!(
                config_err,
                ConfigError::BadConfigVariable {
                    key: "fetch.negotiationalgorithm".to_owned(),
                    file: ".git/config".to_owned(),
                    line,
                },
                "{text:?}"
            );
        }

        let ok = ConfigFile::parse(
            path,
            "[fetch]\n\tnegotiationAlgorithm = skipping\n",
            ConfigScope::Local,
        )
        .expect("valued key parses");
        assert_eq!(ok.entries[0].value.as_deref(), Some("skipping"));
    }
}

#[cfg(test)]
mod loose_compression_tests {
    use std::path::Path;

    use super::{ConfigFile, ConfigScope, ConfigSet, Error};

    fn set_from_snippet(text: &str) -> ConfigSet {
        let path = Path::new(".git/config");
        let file = ConfigFile::parse(path, text, ConfigScope::Local).expect("parse config snippet");
        let mut set = ConfigSet::new();
        set.merge(&file);
        set
    }

    #[test]
    fn big_file_threshold_default_suffixes_and_errors() {
        assert_eq!(
            ConfigSet::new().big_file_threshold().unwrap(),
            512 * 1024 * 1024
        );
        let cases = [
            ("1000", 1000),
            ("0", 0),
            ("4k", 4096),
            ("2m", 2 * 1024 * 1024),
            ("1g", 1024 * 1024 * 1024),
            ("8G", 8 * 1024 * 1024 * 1024),
        ];
        for (raw, want) in cases {
            let set = set_from_snippet(&format!("[core]\n\tbigFileThreshold = {raw}\n"));
            assert_eq!(set.big_file_threshold().unwrap(), want, "value {raw}");
        }
        let set = set_from_snippet("[core]\n\tbigfilethreshold = 1k\n\tbigFileThreshold = 3k\n");
        assert_eq!(set.big_file_threshold().unwrap(), 3 * 1024);

        for raw in ["-1", "12x", "lots", ""] {
            let snippet = if raw.is_empty() {
                "[core]\n\tbigFileThreshold\n".to_owned()
            } else {
                format!("[core]\n\tbigFileThreshold = {raw}\n")
            };
            let err = set_from_snippet(&snippet).big_file_threshold().unwrap_err();
            assert!(
                matches!(
                    err,
                    Error::Config(super::ConfigError::BadNumericValue { ref key, .. })
                        if key == "core.bigfilethreshold"
                ),
                "value {raw:?}: {err:?}"
            );
        }
    }

    #[test]
    fn loose_compression_cascade() {
        let set = ConfigSet::new();
        assert_eq!(
            set.loose_objects_zlib_level().unwrap(),
            ConfigSet::LOOSE_OBJECTS_ZLIB_DEFAULT
        );

        let set = set_from_snippet("[core]\n\tcompression = 0\n");
        assert_eq!(set.loose_objects_zlib_level().unwrap(), 0);

        let set = set_from_snippet("[core]\n\tcompression = 9\n");
        assert_eq!(set.loose_objects_zlib_level().unwrap(), 9);

        let set = set_from_snippet("[core]\n\tcompression = 0\n\tloosecompression = 9\n");
        assert_eq!(set.loose_objects_zlib_level().unwrap(), 9);

        let set = set_from_snippet("[core]\n\tloosecompression = 3\n");
        assert_eq!(set.loose_objects_zlib_level().unwrap(), 3);

        let set = set_from_snippet("[core]\n\tcompression = -1\n");
        assert_eq!(set.loose_objects_zlib_level().unwrap(), 6);

        for level in 0..=9 {
            let set = set_from_snippet(&format!("[core]\n\tloosecompression = {level}\n"));
            assert_eq!(set.loose_objects_zlib_level().unwrap(), level);
        }

        let set = set_from_snippet("[core]\n\tloosecompression = -1\n");
        assert_eq!(set.loose_objects_zlib_level().unwrap(), 6);

        let err = set_from_snippet("[core]\n\tloosecompression = 10\n")
            .loose_objects_zlib_level()
            .unwrap_err();
        assert!(matches!(err, Error::Config(_)));

        let err = set_from_snippet("[core]\n\tloosecompression = not-a-number\n")
            .loose_objects_zlib_level()
            .unwrap_err();
        assert!(matches!(err, Error::Config(_)));

        let err = set_from_snippet("[core]\n\tcompression = 42\n")
            .loose_objects_zlib_level()
            .unwrap_err();
        assert!(matches!(err, Error::Config(_)));

        let err = set_from_snippet("[core]\n\tcompression = nope\n\tloosecompression = 1\n")
            .loose_objects_zlib_level()
            .unwrap_err();
        assert!(matches!(err, Error::Config(_)));

        let err = set_from_snippet("[core]\n\tloosecompression = nope\n\tloosecompression = 1\n")
            .loose_objects_zlib_level()
            .unwrap_err();
        assert!(matches!(err, Error::Config(_)));

        let set = set_from_snippet("[core]\n\tloosecompression = 1\n\tcompression = 9\n");
        assert_eq!(set.loose_objects_zlib_level().unwrap(), 1);

        let err = set_from_snippet("[core]\n\tloosecompression\n")
            .loose_objects_zlib_level()
            .unwrap_err();
        assert!(matches!(err, Error::Config(_)));
    }
}

#[cfg(test)]
mod pack_compression_tests {
    use super::{ConfigFile, ConfigScope, ConfigSet};
    use std::path::Path;

    fn set_from_snippet(text: &str) -> ConfigSet {
        let path = Path::new(".git/config");
        let file = ConfigFile::parse(path, text, ConfigScope::Local).expect("parse config snippet");
        let mut set = ConfigSet::new();
        set.merge(&file);
        set
    }

    #[test]
    fn pack_objects_zlib_level_defaults_to_six() {
        let set = ConfigSet::new();
        assert_eq!(set.pack_objects_zlib_level().unwrap(), 6);
    }

    #[test]
    fn pack_objects_zlib_level_core_compression() {
        let set = set_from_snippet("[core]\n\tcompression = 0\n");
        assert_eq!(set.pack_objects_zlib_level().unwrap(), 0);
        let set = set_from_snippet("[core]\n\tcompression = 9\n");
        assert_eq!(set.pack_objects_zlib_level().unwrap(), 9);
    }

    #[test]
    fn pack_objects_zlib_level_pack_overrides_core() {
        let set = set_from_snippet("[core]\n\tcompression = 9\n[pack]\n\tcompression = 0\n");
        assert_eq!(set.pack_objects_zlib_level().unwrap(), 0);
        let set = set_from_snippet("[core]\n\tcompression = 0\n[pack]\n\tcompression = 9\n");
        assert_eq!(set.pack_objects_zlib_level().unwrap(), 9);
    }

    #[test]
    fn pack_objects_zlib_level_later_core_does_not_override_earlier_pack() {
        let mut set = ConfigSet::new();
        set.merge(
            &ConfigFile::parse(
                Path::new("a"),
                "[pack]\n\tcompression = 9\n",
                ConfigScope::Local,
            )
            .unwrap(),
        );
        set.merge(
            &ConfigFile::parse(
                Path::new("b"),
                "[core]\n\tcompression = 0\n",
                ConfigScope::Local,
            )
            .unwrap(),
        );
        assert_eq!(set.pack_objects_zlib_level().unwrap(), 9);
    }

    #[test]
    fn pack_objects_zlib_level_loosecompression_does_not_block_core_pack_level() {
        let set = set_from_snippet("[core]\n\tloosecompression = 1\n\tcompression = 0\n");
        assert_eq!(set.pack_objects_zlib_level().unwrap(), 0);
    }

    #[test]
    fn pack_objects_zlib_level_pack_wins_after_loose_and_core() {
        let set = set_from_snippet(
            "[core]\n\tloosecompression = 1\n\tcompression = 0\n[pack]\n\tcompression = 9\n",
        );
        assert_eq!(set.pack_objects_zlib_level().unwrap(), 9);
    }
}

#[cfg(test)]
mod config_cache_tests {
    use super::*;
    use filetime::FileTime;

    fn local_opts(git_dir: &Path) -> LoadConfigOptions {
        LoadConfigOptions {
            include_system: false,
            include_ctx: IncludeContext {
                git_dir: Some(git_dir.to_path_buf()),
                ..Default::default()
            },
            ..Default::default()
        }
    }

    fn load_value(caches: &crate::repo_caches::RepoCaches, git_dir: &Path) -> Option<String> {
        let opts = local_opts(git_dir);
        let set = caches
            .load_config_with_options(&Environment::empty(), Some(git_dir), &opts)
            .expect("load cascade");
        set.get("gritcachetest.value")
    }

    fn mtime_of(path: &Path) -> FileTime {
        FileTime::from_last_modification_time(&fs::metadata(path).expect("stat config"))
    }

    fn restore_mtime(path: &Path, stamp: FileTime) {
        filetime::set_file_mtime(path, stamp).expect("restore mtime");
    }

    #[test]
    fn cache_serves_same_stamp_and_config_write_evicts() {
        let caches =
            crate::repo_caches::RepoCaches::new(crate::command_runner::system_command_runner());
        let td = tempfile::tempdir().expect("tempdir");
        let gd = td.path();
        let cfg = gd.join("config");
        fs::write(&cfg, "[gritcachetest]\n\tvalue = aaa\n").expect("write v1");
        let t0 = mtime_of(&cfg);
        assert_eq!(load_value(&caches, gd).as_deref(), Some("aaa"));

        // Same size + restored mtime: indistinguishable by stat, so the cache
        // serves the old parse. (This is the window explicit eviction closes
        // for in-process writers; C git would not re-read at all.)
        fs::write(&cfg, "[gritcachetest]\n\tvalue = bbb\n").expect("write v2");
        restore_mtime(&cfg, t0);
        assert_eq!(load_value(&caches, gd).as_deref(), Some("aaa"));

        // An in-process `ConfigFile::write` plus eviction sees new content even with identical stamps.
        let mut file = ConfigFile::from_path(&cfg, ConfigScope::Local)
            .expect("read config")
            .expect("config exists");
        file.set("gritcachetest.value", "ccc").expect("set value");
        file.write().expect("persist");
        caches.evict_config_for_path(&cfg);
        restore_mtime(&cfg, t0);
        assert_eq!(load_value(&caches, gd).as_deref(), Some("ccc"));
    }

    #[test]
    fn cache_invalidates_on_size_or_existence_change() {
        let caches =
            crate::repo_caches::RepoCaches::new(crate::command_runner::system_command_runner());
        let td = tempfile::tempdir().expect("tempdir");
        let gd = td.path();
        let cfg = gd.join("config");
        // Absent local config is cached as "absent"...
        assert_eq!(load_value(&caches, gd), None);
        // ...and creating the file is a stamp change (None -> Some).
        fs::write(&cfg, "[gritcachetest]\n\tvalue = first\n").expect("create");
        assert_eq!(load_value(&caches, gd).as_deref(), Some("first"));
        // A size change invalidates even with a restored mtime.
        let t0 = mtime_of(&cfg);
        fs::write(&cfg, "[gritcachetest]\n\tvalue = second-longer\n").expect("rewrite");
        restore_mtime(&cfg, t0);
        assert_eq!(load_value(&caches, gd).as_deref(), Some("second-longer"));
    }

    #[test]
    fn include_targets_are_stamped_and_invalidate() {
        let caches =
            crate::repo_caches::RepoCaches::new(crate::command_runner::system_command_runner());
        let td = tempfile::tempdir().expect("tempdir");
        let gd = td.path();
        fs::write(gd.join("config"), "[include]\n\tpath = extra.conf\n").expect("write parent");
        let inc = gd.join("extra.conf");
        fs::write(&inc, "[gritcachetest]\n\tvalue = one\n").expect("write include v1");
        assert_eq!(load_value(&caches, gd).as_deref(), Some("one"));

        // Same-size + restored-mtime rewrite of only the included file: the
        // parse result is served from cache (proving the include target is
        // stamped rather than re-read)...
        let t0 = mtime_of(&inc);
        fs::write(&inc, "[gritcachetest]\n\tvalue = two\n").expect("write include v2");
        restore_mtime(&inc, t0);
        assert_eq!(load_value(&caches, gd).as_deref(), Some("one"));

        // ...while a stat-visible change to the included file invalidates.
        fs::write(&inc, "[gritcachetest]\n\tvalue = two-longer\n").expect("write include v3");
        assert_eq!(load_value(&caches, gd).as_deref(), Some("two-longer"));
    }

    #[test]
    fn missing_include_target_is_watched() {
        let caches =
            crate::repo_caches::RepoCaches::new(crate::command_runner::system_command_runner());
        let td = tempfile::tempdir().expect("tempdir");
        let gd = td.path();
        fs::write(gd.join("config"), "[include]\n\tpath = extra.conf\n").expect("write parent");
        assert_eq!(load_value(&caches, gd), None);

        // The resolved-but-missing target was stamped as absent; creating it
        // must invalidate the cached parse.
        fs::write(gd.join("extra.conf"), "[gritcachetest]\n\tvalue = born\n").expect("create");
        assert_eq!(load_value(&caches, gd).as_deref(), Some("born"));
    }

    #[test]
    fn onbranch_condition_follows_head() {
        let caches =
            crate::repo_caches::RepoCaches::new(crate::command_runner::system_command_runner());
        let td = tempfile::tempdir().expect("tempdir");
        let gd = td.path();
        fs::write(gd.join("HEAD"), "ref: refs/heads/main\n").expect("write HEAD");
        fs::write(
            gd.join("config"),
            "[includeIf \"onbranch:main\"]\n\tpath = branch.conf\n",
        )
        .expect("write config");
        fs::write(
            gd.join("branch.conf"),
            "[gritcachetest]\n\tvalue = onmain\n",
        )
        .expect("write branch config");
        assert_eq!(load_value(&caches, gd).as_deref(), Some("onmain"));

        // Switching branches rewrites HEAD; the stamped HEAD must invalidate
        // the cached cascade so the condition is re-evaluated.
        fs::write(gd.join("HEAD"), "ref: refs/heads/dev\n").expect("rewrite HEAD");
        assert_eq!(load_value(&caches, gd), None);
    }

    #[test]
    #[cfg(unix)]
    fn load_propagates_local_config_io_errors() {
        use std::os::unix::fs::symlink;
        let td = tempfile::tempdir().expect("tempdir");
        let git_dir = td.path();
        let config = git_dir.join("config");
        symlink("config", &config).expect("self-referential symlink");
        let err = ConfigSet::load(&Environment::empty(), Some(git_dir), false).unwrap_err();
        assert!(
            matches!(err, Error::Io(_)),
            "expected I/O error for symlink loop, got {err:?}"
        );
    }
}

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

    /// The char-at-a-time comment stripper the byte scan replaced, kept as the reference.
    fn strip_inline_comment_by_chars(s: &str) -> String {
        let mut in_quote = false;
        let mut last_was_backslash = false;
        let mut result = String::with_capacity(s.len());
        let mut chars = s.chars().peekable();
        while let Some(ch) = chars.next() {
            match ch {
                '"' if !last_was_backslash => {
                    in_quote = !in_quote;
                    result.push(ch);
                    last_was_backslash = false;
                }
                '\\' if !last_was_backslash => {
                    last_was_backslash = true;
                    result.push(ch);
                    if in_quote {
                        if let Some(&next) = chars.peek() {
                            result.push(next);
                            chars.next();
                            last_was_backslash = false;
                        }
                    }
                }
                '#' | ';' if !in_quote && !last_was_backslash => break,
                _ => {
                    last_was_backslash = false;
                    result.push(ch);
                }
            }
        }
        result.trim_end().to_owned()
    }

    fn unclosed_quote_by_chars(line: &str) -> bool {
        let trimmed = line.trim();
        let Some(eq_pos) = trimmed.find('=') else {
            return false;
        };
        let mut in_quote = false;
        let mut last_was_backslash = false;
        for ch in trimmed[eq_pos + 1..].trim_start().chars() {
            match ch {
                '"' if !last_was_backslash => {
                    in_quote = !in_quote;
                    last_was_backslash = false;
                }
                '\\' if !last_was_backslash => {
                    last_was_backslash = true;
                    continue;
                }
                '#' | ';' if !in_quote && !last_was_backslash => return false,
                _ => last_was_backslash = false,
            }
        }
        in_quote
    }

    fn continues_by_chars(line: &str) -> bool {
        let trimmed = line.trim();
        if trimmed.is_empty() || trimmed.starts_with('#') || trimmed.starts_with(';') {
            return false;
        }
        let Some(pos) = trimmed.find('=') else {
            return false;
        };
        let mut in_quote = false;
        let mut last_was_backslash = false;
        let mut in_comment = false;
        for ch in trimmed[pos + 1..].chars() {
            if in_comment {
                last_was_backslash = false;
                continue;
            }
            match ch {
                '"' if !last_was_backslash => {
                    in_quote = !in_quote;
                    last_was_backslash = false;
                }
                '\\' if !last_was_backslash => {
                    last_was_backslash = true;
                    continue;
                }
                '#' | ';' if !in_quote && !last_was_backslash => {
                    in_comment = true;
                    last_was_backslash = false;
                }
                _ => last_was_backslash = false,
            }
        }
        last_was_backslash && !in_comment
    }

    /// Every string of up to five tokens drawn from the characters the scanners treat
    /// specially, plus ASCII and multi-byte text and Unicode whitespace.
    fn corpus() -> Vec<String> {
        const TOKENS: [&str; 11] = [
            "a", "\"", "\\", "#", ";", " ", "=", "\t", "é", "日", "\u{2003}",
        ];
        let mut out = vec![String::new()];
        let mut frontier = vec![String::new()];
        for _ in 0..5 {
            let mut next = Vec::with_capacity(frontier.len() * TOKENS.len());
            for prefix in &frontier {
                for token in TOKENS {
                    next.push(format!("{prefix}{token}"));
                }
            }
            out.extend(next.iter().cloned());
            frontier = next;
        }
        out
    }

    #[test]
    fn byte_scanners_match_char_scanners_on_every_short_line() {
        for s in corpus() {
            assert_eq!(
                strip_inline_comment(&s),
                strip_inline_comment_by_chars(&s),
                "strip_inline_comment({s:?})"
            );
            let line = format!("k = {s}");
            assert_eq!(
                entry_line_value_has_unclosed_quote(&line),
                unclosed_quote_by_chars(&line),
                "unclosed quote in {line:?}"
            );
            assert_eq!(
                value_line_continues(&line),
                continues_by_chars(&line),
                "continuation of {line:?}"
            );
            assert_eq!(
                entry_line_value_has_unclosed_quote(&s),
                unclosed_quote_by_chars(&s),
                "unclosed quote in {s:?}"
            );
            assert_eq!(
                value_line_continues(&s),
                continues_by_chars(&s),
                "continuation of {s:?}"
            );
        }
    }

    #[test]
    fn strip_inline_comment_borrows_a_prefix() {
        let s = "\"a # b\" tail ; comment";
        let stripped = strip_inline_comment(s);
        assert_eq!(stripped, "\"a # b\" tail");
        assert_eq!(stripped.as_ptr(), s.as_ptr());
        assert_eq!(strip_inline_comment("\"\\\"#\" x"), "\"\\\"#\" x");
        assert_eq!(strip_inline_comment("v\\#kept # gone"), "v\\#kept");
    }

    #[test]
    fn canonical_key_lowercases_section_and_name_only() {
        assert_eq!(canonical_key("core.bare").unwrap(), "core.bare");
        assert_eq!(canonical_key("CORE.BARE").unwrap(), "core.bare");
        assert_eq!(
            canonical_key("Remote.Origin.URL").unwrap(),
            "remote.Origin.url"
        );
        assert_eq!(canonical_key("a.B.C.D").unwrap(), "a.B.C.d");
        assert!(canonical_key("nodot").is_err());
        assert!(canonical_key("core.").is_err());
        assert!(canonical_key("core.1bad").is_err());
        assert!(canonical_key("core.ba\nre").is_err());
    }

    #[test]
    fn parsed_keys_reuse_the_section_prefix_per_header() {
        let text = "[Core]\n\tBare = false\n\tFileMode\n\
                    [Remote \"Origin\"]\n\tURL = /x\n\
                    [branch \"Main\"] Remote = origin\n\
                    [core]\n\tEditor = vi ; trailing\n";
        let file = ConfigFile::parse(Path::new("cfg"), text, ConfigScope::Local).unwrap();
        let keys: Vec<(&str, Option<&str>)> = file
            .entries
            .iter()
            .map(|e| (e.key.as_str(), e.value.as_deref()))
            .collect();
        assert_eq!(
            keys,
            [
                ("core.bare", Some("false")),
                ("core.filemode", None),
                ("remote.Origin.url", Some("/x")),
                ("branch.Main.remote", Some("origin")),
                ("core.editor", Some("vi")),
            ]
        );
    }

    #[test]
    fn push_lowercase_matches_to_lowercase() {
        for s in ["", "core", "MiXeD-09", "ÄBC", "İx", "ΣΑΣ"] {
            let mut out = String::from("p.");
            push_lowercase(&mut out, s);
            assert_eq!(out, format!("p.{}", s.to_lowercase()));
        }
    }
}