grit_lib/apply/

mod.rs

//! Unified/`git`-diff patch parsing and blob-level hunk application.
//!
//! Parses patch text into structured [`FilePatch`]/[`Hunk`] data with no I/O or
//! environment access. [`apply_hunks_to_blob`] applies hunks to a single blob
//! in memory (worktree/index application is built on this in later layers).
//!
//! Library guide: [apply](https://grit-scm.com/docs/library/embedding)
//!
//! ```rust
//! use grit_lib::repo::{InitOptions, Repository};
//! # fn main() -> grit_lib::error::Result<()> {
//! let dir = tempfile::tempdir()?;
//! let _repo = Repository::init(dir.path(), &InitOptions::default())?;
//! # Ok(())
//! # }
//! ```

mod apply_blob;

pub use apply_blob::{apply_hunks_to_blob, ApplyOptions};

use crate::error::{ApplyError, Error, Result};
use crate::quote_path_root::unquote_c_style_prefix;
use regex::Regex;
use std::sync::OnceLock;

/// A single hunk in a unified diff.
#[derive(Debug, Clone)]
pub struct Hunk {
    /// 1-based line number in the old file.
    pub old_start: usize,
    /// Number of lines in the old side.
    pub old_count: usize,
    /// 1-based line number in the new file.
    pub new_start: usize,
    /// Number of lines on the new side.
    pub new_count: usize,
    /// 1-based line number in the patch file of the first hunk body line (line after `@@`).
    pub first_body_line: usize,
    /// Lines of the hunk body (' ', '+', '-' prefixed, or bare '\' no newline).
    pub lines: Vec<HunkLine>,
}

/// One line in a unified-diff hunk body.
#[derive(Debug, Clone)]
pub enum HunkLine {
    /// Unchanged context line (leading space in the patch).
    Context(String),
    /// Added line (leading `+`).
    Add(String),
    /// Removed line (leading `-`).
    Remove(String),
    /// "\ No newline at end of file"
    NoNewline,
}

/// Represents one file in a unified diff.
#[derive(Debug, Clone)]
pub struct FilePatch {
    /// Path from `diff --git` old side (`a/...`) when present.
    pub diff_old_path: Option<String>,
    /// Path from `diff --git` new side (`b/...`) when present.
    pub diff_new_path: Option<String>,
    /// Path on the old side (None for new files).
    pub old_path: Option<String>,
    /// Path on the new side (None for deleted files).
    pub new_path: Option<String>,
    /// Whether an explicit `---` header line was present.
    pub saw_old_header: bool,
    /// Whether an explicit `+++` header line was present.
    pub saw_new_header: bool,
    /// Old mode from extended header.
    pub old_mode: Option<String>,
    /// New mode from extended header.
    pub new_mode: Option<String>,
    /// Source line (1-based) of `old mode` / `deleted file mode` for diagnostics.
    pub old_mode_line: Option<usize>,
    /// Source line (1-based) of `new mode` / `new file mode` for diagnostics.
    pub new_mode_line: Option<usize>,
    /// Whether this file is being newly created.
    pub is_new: bool,
    /// Whether this file is being deleted.
    pub is_deleted: bool,
    /// Whether this is a rename.
    pub is_rename: bool,
    /// Whether this is a copy.
    pub is_copy: bool,
    /// Similarity index (e.g., 90 for 90%).
    pub similarity_index: Option<u32>,
    /// Dissimilarity index for rewrites.
    pub dissimilarity_index: Option<u32>,
    /// Old blob OID from the index header (abbreviated).
    pub old_oid: Option<String>,
    /// New blob OID from the index header (abbreviated).
    pub new_oid: Option<String>,
    /// Parsed binary patch payload (`GIT binary patch`) if present.
    pub binary_patch: Option<BinaryPatchPayload>,
    /// Whether this is a binary change (`GIT binary patch` payload or a
    /// `Binary files ... differ` marker); stat/numstat show `Bin` / `-`.
    pub is_binary: bool,
    /// Hunks to apply.
    pub hunks: Vec<Hunk>,
    /// Merged `core.whitespace` + `whitespace` attribute (Git `ws_rule`); `0` before assignment.
    pub ws_rule: u32,
    /// Git `patch->is_toplevel_relative`: set for `diff --git` patches only. When false, paths are
    /// prefixed with the setup directory (work-tree-relative CWD) like `prefix_patch` in Git.
    pub is_toplevel_relative: bool,
}

/// Whether a `GIT binary patch` section holds a full literal or a delta against the other side.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BinaryPatchSectionKind {
    /// Zlib-compressed full file contents (`literal N`).
    Literal,
    /// Zlib-compressed Git binary delta (`delta N`) applied to the preimage blob.
    Delta,
}

/// One forward or reverse chunk in a `GIT binary patch`.
#[derive(Debug, Clone)]
pub struct BinaryPatchSection {
    /// Whether this chunk is a full literal or a delta.
    pub kind: BinaryPatchSectionKind,
    /// Zlib-compressed payload from the `GIT binary patch` section.
    pub compressed: Vec<u8>,
    /// Declared uncompressed size from the section header (`literal N` / `delta N`).
    pub declared_size: usize,
}

/// Binary patch payload as compressed base85 chunks for forward/reverse apply.
#[derive(Debug, Clone)]
pub struct BinaryPatchPayload {
    /// Forward-direction patch chunk applied when checking out the new blob.
    pub forward: BinaryPatchSection,
    /// Reverse section when present (second `literal`/`delta` block).
    pub reverse: Option<BinaryPatchSection>,
}

impl FilePatch {
    fn empty() -> Self {
        Self {
            diff_old_path: None,
            diff_new_path: None,
            old_path: None,
            new_path: None,
            saw_old_header: false,
            saw_new_header: false,
            old_mode: None,
            new_mode: None,
            old_mode_line: None,
            new_mode_line: None,
            is_new: false,
            is_deleted: false,
            is_rename: false,
            is_copy: false,
            similarity_index: None,
            dissimilarity_index: None,
            old_oid: None,
            new_oid: None,
            binary_patch: None,
            is_binary: false,
            hunks: Vec::new(),
            ws_rule: 0,
            is_toplevel_relative: false,
        }
    }

    /// Effective path for the file.
    /// For deletions, use old_path (new is /dev/null).
    /// For additions, use new_path (old is /dev/null).
    /// Otherwise prefer new_path.
    pub fn effective_path(&self) -> Option<&str> {
        if self.is_deleted {
            return self
                .old_path
                .as_deref()
                .filter(|p| *p != "/dev/null")
                .or(self.new_path.as_deref().filter(|p| *p != "/dev/null"));
        }
        if self.is_new {
            return self
                .new_path
                .as_deref()
                .filter(|p| *p != "/dev/null")
                .or(self.old_path.as_deref().filter(|p| *p != "/dev/null"));
        }
        self.new_path
            .as_deref()
            .filter(|p| *p != "/dev/null")
            .or(self.old_path.as_deref().filter(|p| *p != "/dev/null"))
    }

    /// Source path to read preimage content from.
    ///
    /// For rename/copy patches this is the old path, otherwise this is the
    /// effective path.
    pub fn source_path(&self) -> Option<&str> {
        if self.is_rename || self.is_copy {
            self.old_path
                .as_deref()
                .filter(|p| *p != "/dev/null")
                .or(self.effective_path())
        } else if let (Some(old), Some(new)) = (self.old_path.as_deref(), self.new_path.as_deref())
        {
            if old != "/dev/null" && new != "/dev/null" && old != new {
                Some(old)
            } else {
                self.effective_path()
            }
        } else {
            self.effective_path()
        }
    }

    /// Destination path to write postimage content to.
    ///
    /// For additions/renames/copies this is the new path, otherwise this is
    /// the effective path.
    pub fn target_path(&self) -> Option<&str> {
        if self.is_new || self.is_rename || self.is_copy {
            self.new_path
                .as_deref()
                .filter(|p| *p != "/dev/null")
                .or(self.effective_path())
        } else {
            self.effective_path()
        }
    }

    /// True when this patch touches a gitlink/submodule (mode `160000`).
    pub fn involves_gitlink(&self) -> bool {
        self.old_mode.as_deref() == Some("160000") || self.new_mode.as_deref() == Some("160000")
    }
}

/// Strip trailing `\r` and surrounding whitespace from parsed header tokens.
///
/// `git diff` may emit CRLF line endings; without this, `new mode 160000\r` fails to match
/// submodule handling (`t4137-apply-submodule`).
fn sanitize_patch_header_value(s: &mut String) {
    *s = s.trim().trim_end_matches('\r').to_string();
}

/// Strip Git's `diff --git a/... b/...` path prefix when it leaked into stored paths.
///
/// Binary patches often omit `---`/`+++` lines that would normally resynchronize names; without
/// this, paths like `a/bin.png` are misinterpreted as real file paths (`t4108-apply-threeway`).
fn strip_git_diff_path_prefix(path: &str) -> String {
    if path == "/dev/null" {
        return path.to_string();
    }
    let p = path.trim_start_matches("./");
    if let Some(rest) = p.strip_prefix("a/") {
        return rest.to_string();
    }
    if let Some(rest) = p.strip_prefix("b/") {
        return rest.to_string();
    }
    path.to_string()
}

fn sanitize_file_patch_headers(fp: &mut FilePatch) {
    if let Some(ref mut s) = fp.old_mode {
        sanitize_patch_header_value(s);
        if s.is_empty() {
            fp.old_mode = None;
        }
    }
    if let Some(ref mut s) = fp.new_mode {
        sanitize_patch_header_value(s);
        if s.is_empty() {
            fp.new_mode = None;
        }
    }
    if let Some(ref mut s) = fp.old_oid {
        sanitize_patch_header_value(s);
    }
    if let Some(ref mut s) = fp.new_oid {
        sanitize_patch_header_value(s);
    }
    for ref mut s in [
        &mut fp.diff_old_path,
        &mut fp.diff_new_path,
        &mut fp.old_path,
        &mut fp.new_path,
    ]
    .into_iter()
    .flatten()
    {
        sanitize_patch_header_value(s);
        **s = strip_git_diff_path_prefix(s);
    }
}

/// Collapse runs of `/` to a single slash (Git `squash_slash`).
fn squash_slash_path(s: &str) -> String {
    let mut out = String::with_capacity(s.len());
    let mut prev_slash = false;
    for ch in s.chars() {
        if ch == '/' {
            if !prev_slash {
                out.push('/');
            }
            prev_slash = true;
        } else {
            prev_slash = false;
            out.push(ch);
        }
    }
    out
}

fn bytes_to_path_string(bytes: &[u8]) -> Result<String> {
    let s = String::from_utf8(bytes.to_vec())
        .map_err(|e| Error::Message(format!("diff path is not valid UTF-8: {e}")))?;
    Ok(squash_slash_path(&s))
}

/// Skip `p_value` leading path components (Git `skip_tree_prefix`); `p_value == 0` allows absolute paths.
fn skip_tree_prefix_bytes(line: &[u8], p_value: usize) -> Option<&[u8]> {
    if p_value == 0 {
        return Some(line);
    }
    let mut nslash = p_value;
    let mut i = 0usize;
    while i < line.len() {
        if line[i] == b'/' {
            nslash = nslash.saturating_sub(1);
            if nslash == 0 {
                return if i == 0 { None } else { Some(&line[i + 1..]) };
            }
        }
        i += 1;
    }
    None
}

/// Strip `p_value` leading `/`-separated components from a UTF-8 path (for `rename from` etc.).
fn skip_tree_prefix_str(path: &str, p_value: usize) -> Option<String> {
    let stripped = skip_tree_prefix_bytes(path.as_bytes(), p_value)?;
    Some(String::from_utf8_lossy(stripped).into_owned())
}

fn sane_tz_len(line: &[u8]) -> usize {
    const SUFFIX: &[u8] = b" +0500";
    if line.len() < SUFFIX.len() || line[line.len() - SUFFIX.len()] != b' ' {
        return 0;
    }
    let tz = &line[line.len() - SUFFIX.len()..];
    if tz[1] != b'+' && tz[1] != b'-' {
        return 0;
    }
    for p in &tz[2..] {
        if !p.is_ascii_digit() {
            return 0;
        }
    }
    SUFFIX.len()
}

fn tz_with_colon_len(line: &[u8]) -> usize {
    // Git: suffix is ` ±HH:MM` (space, sign, two hour digits, colon, two minute digits) = 7 bytes.
    const SUFFIX_LEN: usize = 7;
    if line.len() < SUFFIX_LEN || line[line.len() - 3] != b':' {
        return 0;
    }
    let tz = &line[line.len() - SUFFIX_LEN..];
    if tz[0] != b' ' || (tz[1] != b'+' && tz[1] != b'-') {
        return 0;
    }
    let p = &tz[2..];
    if p.len() != 5
        || !p[0].is_ascii_digit()
        || !p[1].is_ascii_digit()
        || p[2] != b':'
        || !p[3].is_ascii_digit()
        || !p[4].is_ascii_digit()
    {
        return 0;
    }
    SUFFIX_LEN
}

fn date_len(line: &[u8]) -> usize {
    const SHORT: &[u8] = b"72-02-05";
    if line.len() < SHORT.len() || line[line.len() - 3] != b'-' {
        return 0;
    }
    let mut p = line.len() - SHORT.len();
    let date = &line[p..];
    if !date[0].is_ascii_digit()
        || !date[1].is_ascii_digit()
        || date[2] != b'-'
        || !date[3].is_ascii_digit()
        || !date[4].is_ascii_digit()
        || date[5] != b'-'
        || !date[6].is_ascii_digit()
        || !date[7].is_ascii_digit()
    {
        return 0;
    }
    if p >= 2 {
        let y1 = line[p - 1];
        let y2 = line[p - 2];
        if y1.is_ascii_digit() && y2.is_ascii_digit() {
            p -= 2;
        }
    }
    line.len() - p
}

fn short_time_len(line: &[u8]) -> usize {
    const PAT: &[u8] = b" 07:01:32";
    if line.len() < PAT.len() || line[line.len() - 3] != b':' {
        return 0;
    }
    let p = line.len() - PAT.len();
    let time = &line[p..];
    if time[0] != b' '
        || !time[1].is_ascii_digit()
        || !time[2].is_ascii_digit()
        || time[3] != b':'
        || !time[4].is_ascii_digit()
        || !time[5].is_ascii_digit()
        || time[6] != b':'
        || !time[7].is_ascii_digit()
        || !time[8].is_ascii_digit()
    {
        return 0;
    }
    PAT.len()
}

fn fractional_time_len(line: &[u8]) -> usize {
    if line.is_empty() || !line[line.len() - 1].is_ascii_digit() {
        return 0;
    }
    let mut p = line.len() - 1;
    while p > 0 && line[p].is_ascii_digit() {
        p -= 1;
    }
    if p == 0 || line[p] != b'.' {
        return 0;
    }
    let n = short_time_len(&line[..p]);
    if n == 0 {
        return 0;
    }
    line.len() - p + n
}

fn trailing_spaces_len(line: &[u8]) -> usize {
    if line.is_empty() || line[line.len() - 1] != b' ' {
        return 0;
    }
    let mut p = line.len();
    while p > 0 {
        p -= 1;
        if line[p] != b' ' {
            return line.len() - (p + 1);
        }
    }
    line.len()
}

fn diff_timestamp_len(line: &[u8]) -> usize {
    if line.is_empty() || !line[line.len() - 1].is_ascii_digit() {
        return 0;
    }
    let mut end = line.len();
    let mut n = sane_tz_len(&line[..end]);
    if n == 0 {
        n = tz_with_colon_len(&line[..end]);
    }
    if n == 0 {
        return 0;
    }
    end -= n;

    n = short_time_len(&line[..end]);
    if n == 0 {
        n = fractional_time_len(&line[..end]);
    }
    if n == 0 {
        return 0;
    }
    end -= n;

    n = date_len(&line[..end]);
    if n == 0 {
        return 0;
    }
    end -= n;

    if end == 0 {
        return 0;
    }
    match line[end - 1] {
        b'\t' => {
            end -= 1;
            line.len() - end
        }
        b' ' => {
            end -= trailing_spaces_len(&line[..end]);
            line.len() - end
        }
        _ => 0,
    }
}

/// Git `find_name_common` with optional `end` bound (exclusive).
fn find_name_common_bounded(
    line: &[u8],
    def: Option<&[u8]>,
    p_value: usize,
    end: usize,
) -> Option<Vec<u8>> {
    let end = end.min(line.len());
    let mut start: Option<usize> = if p_value == 0 { Some(0) } else { None };
    let mut p = p_value;
    let mut i = 0usize;
    while i < end {
        let c = line[i];
        i += 1;
        if c == b'/' && p > 0 {
            p -= 1;
            if p == 0 {
                start = Some(i);
            }
        }
    }
    let start = start?;
    let len = i - start;
    if len == 0 {
        return def.map(|d| d.to_vec());
    }
    let slice = &line[start..i];
    if let Some(d) = def {
        if d.len() < len && slice.starts_with(d) {
            return Some(d.to_vec());
        }
    }
    Some(slice.to_vec())
}

/// Git `find_name_traditional` on the line after `--- ` / `+++ ` (no prefix).
fn find_name_traditional(line: &[u8], def: Option<&[u8]>, p_value: usize) -> Option<Vec<u8>> {
    if line.first() == Some(&b'"') {
        let (decoded, _) = unquote_c_style_prefix(std::str::from_utf8(line).ok()?)?;
        let skip = skip_tree_prefix_bytes(&decoded, p_value)?;
        return Some(skip.to_vec());
    }
    let ts = diff_timestamp_len(line);
    let name_end = line.len().saturating_sub(ts);
    find_name_common_bounded(line, def, p_value, name_end)
}

fn find_name_tab_terminated(line: &[u8], p_value: usize) -> Option<Vec<u8>> {
    if line.first() == Some(&b'"') {
        let (decoded, _) = unquote_c_style_prefix(std::str::from_utf8(line).ok()?)?;
        let skip = skip_tree_prefix_bytes(&decoded, p_value)?;
        return Some(skip.to_vec());
    }
    let end = line
        .iter()
        .position(|&b| b == b'\t' || b == b'\n' || b == b'\r')
        .unwrap_or(line.len());
    find_name_common_bounded(line, None, p_value, end)
}

fn is_dev_null_nameline(line: &[u8]) -> bool {
    line.strip_prefix(b"/dev/null")
        .map(|rest| rest.is_empty() || rest.first().is_some_and(|b| b.is_ascii_whitespace()))
        .unwrap_or(false)
}

fn count_slashes_in_prefix(prefix: &str) -> usize {
    prefix.bytes().filter(|&b| b == b'/').count()
}

/// Git `guess_p_value` for traditional patches (`apply.c`). Uses `setup_git_directory` prefix.
fn guess_p_value_from_nameline(line: &[u8], setup_prefix: Option<&str>) -> Option<usize> {
    if is_dev_null_nameline(line) {
        return None;
    }
    let name = find_name_traditional(line, None, 0)?;
    let name_str = String::from_utf8_lossy(&name);
    if !name_str.contains('/') {
        return Some(0);
    }
    let pfx = setup_prefix.filter(|p| !p.is_empty())?;
    if name_str.starts_with(pfx) {
        return Some(count_slashes_in_prefix(pfx));
    }
    let slash = name_str.find('/')?;
    let rest = name_str.get(slash + 1..)?;
    if rest.starts_with(pfx) {
        return Some(count_slashes_in_prefix(pfx) + 1);
    }
    None
}

fn epoch_stamp_regex() -> &'static Regex {
    // hygiene: immutable compiled regex for patch epoch stamps
    static RE: OnceLock<Regex> = OnceLock::new();
    RE.get_or_init(|| {
        // Provably infallible: the pattern is a fixed string literal that is a valid regex.
        #[allow(clippy::expect_used)]
        Regex::new(r"^([0-2][0-9]):([0-5][0-9]):00(?:\.0+)? ([-+][0-2][0-9]:?[0-5][0-9])")
            .expect("epoch stamp regex is a valid constant pattern")
    })
}

/// True when the `---`/`+++` line has a tab-separated epoch timestamp (Git `has_epoch_timestamp`).
fn has_epoch_timestamp(nameline: &[u8]) -> bool {
    let Some(tab) = nameline.iter().position(|&b| b == b'\t') else {
        return false;
    };
    let mut ts = &nameline[tab + 1..];
    let epoch_hour = if let Some(r) = ts.strip_prefix(b"1969-12-31 ") {
        ts = r;
        24i32
    } else if let Some(r) = ts.strip_prefix(b"1970-01-01 ") {
        ts = r;
        0i32
    } else {
        return false;
    };
    let end = ts.iter().position(|&b| b == b'\n').unwrap_or(ts.len());
    let stamp = &ts[..end];
    let stamp_str = match std::str::from_utf8(stamp) {
        Ok(s) => s,
        Err(_) => return false,
    };
    let caps = match epoch_stamp_regex().captures(stamp_str) {
        Some(c) => c,
        None => return false,
    };
    let hour: i32 = caps
        .get(1)
        .and_then(|m| m.as_str().parse().ok())
        .unwrap_or(-1);
    let minute: i32 = caps
        .get(2)
        .and_then(|m| m.as_str().parse().ok())
        .unwrap_or(-1);
    let tz_s = match caps.get(3).map(|m| m.as_str()) {
        Some(s) if !s.is_empty() => s,
        _ => return false,
    };
    if hour < 0 || minute < 0 {
        return false;
    }
    let tz_byte = tz_s.as_bytes()[0];
    let tz_rest = &tz_s[1..];
    let zoneoffset: i32 = if let Some(colon_pos) = tz_rest.find(':') {
        let h: i32 = tz_rest[..colon_pos].parse().unwrap_or(0);
        let mm: i32 = tz_rest[colon_pos + 1..].parse().unwrap_or(0);
        h * 60 + mm
    } else if tz_rest.len() >= 4 {
        let n: i32 = tz_rest[..4].parse().unwrap_or(0);
        (n / 100) * 60 + (n % 100)
    } else {
        return false;
    };
    let zoneoffset = if tz_byte == b'-' {
        -zoneoffset
    } else {
        zoneoffset
    };
    hour * 60 + minute - zoneoffset == epoch_hour * 60
}

/// Parse `---` / `+++` pair for a traditional unified diff (Git `parse_traditional_patch`).
fn parse_traditional_patch_pair(
    old_line: &[u8],
    new_line: &[u8],
    strip: usize,
    p_guess: &mut Option<usize>,
    setup_prefix: Option<&str>,
) -> Result<FilePatch> {
    let old_p = old_line.strip_prefix(b"--- ").unwrap_or(old_line);
    let new_p = new_line.strip_prefix(b"+++ ").unwrap_or(new_line);

    if p_guess.is_none() {
        let p = guess_p_value_from_nameline(old_p, setup_prefix);
        let q = guess_p_value_from_nameline(new_p, setup_prefix);
        let chosen = match (p, q) {
            (None, None) => None,
            (Some(a), None) => Some(a),
            (None, Some(b)) => Some(b),
            (Some(a), Some(b)) if a == b => Some(a),
            _ => None,
        };
        *p_guess = chosen;
    }
    let p_val = p_guess.unwrap_or(strip);

    let mut fp = FilePatch {
        saw_old_header: true,
        saw_new_header: true,
        ..FilePatch::empty()
    };

    if is_dev_null_nameline(old_p) {
        fp.is_new = true;
        let name = find_name_traditional(new_p, None, p_val).ok_or_else(|| {
            Error::Message("unable to find filename in traditional patch".to_string())
        })?;
        fp.new_path = Some(bytes_to_path_string(&name)?);
    } else if is_dev_null_nameline(new_p) {
        fp.is_deleted = true;
        let name = find_name_traditional(old_p, None, p_val).ok_or_else(|| {
            Error::Message("unable to find filename in traditional patch".to_string())
        })?;
        fp.old_path = Some(bytes_to_path_string(&name)?);
    } else {
        let first_name = find_name_traditional(old_p, None, p_val).ok_or_else(|| {
            Error::Message("unable to find filename in traditional patch".to_string())
        })?;
        let name = find_name_traditional(new_p, Some(&first_name), p_val).ok_or_else(|| {
            Error::Message("unable to find filename in traditional patch".to_string())
        })?;
        let name_str = bytes_to_path_string(&name)?;
        if has_epoch_timestamp(old_p) {
            fp.is_new = true;
            fp.new_path = Some(name_str);
        } else if has_epoch_timestamp(new_p) {
            fp.is_deleted = true;
            fp.old_path = Some(name_str);
        } else {
            // Git uses the `+++` filename for both sides when neither line carries an epoch
            // marker; the `---` line only participates via `def` when shortening `.orig` etc.
            fp.old_path = Some(name_str.clone());
            fp.new_path = Some(name_str);
        }
    }

    Ok(fp)
}

/// Default filename from `diff --git` when both sides agree (Git `git_header_name`).
fn git_header_def_name(line: &str, p_value: usize) -> Option<String> {
    let rest = line.strip_prefix("diff --git ").unwrap_or(line);
    let rest_b = rest.as_bytes();

    if rest_b.first() == Some(&b'"') {
        let (first_decoded, second_raw) = unquote_c_style_prefix(rest)?;
        let rel_first = skip_tree_prefix_bytes(&first_decoded, p_value)?;
        let second = second_raw.trim_start_matches(|c: char| c.is_ascii_whitespace());
        if second.is_empty() {
            return None;
        }
        if second.as_bytes().first() == Some(&b'"') {
            let (second_decoded, _) = unquote_c_style_prefix(second)?;
            let rel2 = skip_tree_prefix_bytes(&second_decoded, p_value)?;
            if rel2 != rel_first {
                return None;
            }
        } else {
            let rel2 = skip_tree_prefix_bytes(second.as_bytes(), p_value)?;
            if rel2.len() != rel_first.len() || rel2 != rel_first {
                return None;
            }
        }
        return bytes_to_path_string(rel_first).ok();
    }

    let name = skip_tree_prefix_bytes(rest_b, p_value)?;
    let name_start = name.as_ptr() as usize - rest_b.as_ptr() as usize;

    for offset in 0..name.len() {
        if name[offset] != b'"' {
            continue;
        }
        let second_slice = &rest_b[name_start + offset..];
        let (decoded, _) = unquote_c_style_prefix(std::str::from_utf8(second_slice).ok()?)?;
        let np = skip_tree_prefix_bytes(&decoded, p_value)?;
        let plen = np.len();
        if plen < offset
            && name.len() > plen
            && &name[..plen] == np
            && name[plen].is_ascii_whitespace()
        {
            return bytes_to_path_string(np).ok();
        }
        return None;
    }

    let line_len = rest.len().saturating_sub(name_start);
    let mut len = 0usize;
    while len < line_len {
        match rest_b[name_start + len] {
            b'\n' => return None,
            b'\t' | b' ' => {
                let after = name_start + len + 1;
                if after > name_start + line_len {
                    return None;
                }
                let second =
                    skip_tree_prefix_bytes(&rest_b[after..name_start + line_len], p_value)?;
                let names_match =
                    name.len() >= len && second.len() >= len && name[..len] == second[..len];
                let boundary_ok = second.get(len) == Some(&b'\n') || second.len() == len;
                if names_match && boundary_ok {
                    return bytes_to_path_string(&name[..len]).ok();
                }
            }
            _ => {}
        }
        len += 1;
    }
    None
}

/// Path from `rename from` / `copy from` lines (Git `find_name` with `terminate == 0`).
fn find_name_extended_header(rest: &str, p_extended: usize) -> Option<String> {
    let rest = rest.trim_end_matches(['\r', '\n']);
    let b = rest.as_bytes();
    if b.first() == Some(&b'"') {
        let (decoded, tail) = unquote_c_style_prefix(rest)?;
        if !tail.trim().is_empty() {
            return None;
        }
        let skip = skip_tree_prefix_bytes(&decoded, p_extended)?;
        return bytes_to_path_string(skip).ok();
    }
    let end = b
        .iter()
        .position(|&c| c == b'\t' || c == b'\n' || c == b'\r' || c == b' ')
        .unwrap_or(b.len());
    let name = find_name_common_bounded(b, None, p_extended, end)?;
    bytes_to_path_string(&name).ok()
}

/// Parse a unified diff into a list of `FilePatch` entries.
///
/// `strip` is Git's `p_value` (`-p` count, default 1). `setup_prefix` is Git's
/// `setup_git_directory` prefix (work-tree-relative path from CWD to the repo
/// root, with trailing `/`); pass `None` when running from the work-tree root.
/// The caller computes it because it is a CLI/environment concern.
pub fn parse_patch(
    input: &str,
    strip: usize,
    input_name: &str,
    recount: bool,
    setup_prefix: Option<&str>,
) -> Result<Vec<FilePatch>> {
    let lines: Vec<&str> = input.lines().collect();
    let mut patches = Vec::new();
    let mut i = 0;
    let mut p_guess_for_traditional = None;
    let setup_prefix_for_guess = setup_prefix.filter(|p| !p.is_empty());

    while i < lines.len() {
        let mut fp = if lines[i].starts_with("diff --git ") {
            let (fp, next_i) = parse_git_patch_header(&lines, i, strip)?;
            i = next_i;
            fp
        } else if lines[i].starts_with("--- ")
            && i + 1 < lines.len()
            && lines[i + 1].starts_with("+++ ")
        {
            let fp = parse_traditional_patch_pair(
                lines[i].as_bytes(),
                lines[i + 1].as_bytes(),
                strip,
                &mut p_guess_for_traditional,
                setup_prefix_for_guess,
            )?;
            i += 2;
            while i < lines.len() && lines[i].starts_with("index ") {
                i += 1;
            }
            fp
        } else {
            i += 1;
            continue;
        };

        if i < lines.len() && lines[i] == "GIT binary patch" {
            let (binary_patch, next_i) = parse_binary_patch(&lines, i + 1)?;
            fp.binary_patch = Some(binary_patch);
            fp.is_binary = true;
            i = next_i;
        } else {
            while i < lines.len() && lines[i].starts_with("@@ ") {
                let (hunk, next_i) = parse_hunk(&lines, i, input_name, recount)?;
                fp.hunks.push(hunk);
                i = next_i;
            }
        }

        sanitize_file_patch_headers(&mut fp);
        patches.push(fp);
    }

    Ok(patches)
}

// Binary sections among extended headers are consumed here; those following
// explicit file headers are consumed by the common patch-body loop.
fn parse_git_patch_header(
    lines: &[&str],
    mut i: usize,
    strip: usize,
) -> Result<(FilePatch, usize)> {
    let p_strip = strip;
    let p_extended = strip.saturating_sub(1);
    let mut fp = FilePatch {
        is_toplevel_relative: true,
        ..FilePatch::empty()
    };

    let header_line = lines[i];
    let def_name = git_header_def_name(header_line, p_strip);

    // Parse "diff --git a/foo b/foo"
    let rest = &header_line["diff --git ".len()..];
    if let Some((a, b)) = split_diff_git_paths(rest) {
        fp.diff_old_path = Some(a.clone());
        fp.diff_new_path = Some(b.clone());
        fp.old_path = Some(skip_tree_prefix_str(&a, p_strip).ok_or_else(|| {
            Error::Message(format!("malformed old path in diff --git header: {a}"))
        })?);
        fp.new_path = Some(skip_tree_prefix_str(&b, p_strip).ok_or_else(|| {
            Error::Message(format!("malformed new path in diff --git header: {b}"))
        })?);
    }
    i += 1;

    // Parse extended headers
    while i < lines.len()
        && !lines[i].starts_with("--- ")
        && !lines[i].starts_with("diff --git ")
        && !lines[i].starts_with("@@ ")
    {
        let line = lines[i];
        let line_no = i + 1;
        if let Some(val) = line.strip_prefix("old mode ") {
            let v = val.trim_end_matches('\r').trim_end();
            if v.is_empty() {
                return Err(Error::Message(format!(
                    "invalid mode on line {line_no}: {line}"
                )));
            }
            fp.old_mode = Some(v.to_string());
            fp.old_mode_line = Some(line_no);
        } else if let Some(val) = line.strip_prefix("new mode ") {
            let v = val.trim_end_matches('\r').trim_end();
            if v.is_empty() {
                return Err(Error::Message(format!(
                    "invalid mode on line {line_no}: {line}"
                )));
            }
            fp.new_mode = Some(v.to_string());
            fp.new_mode_line = Some(line_no);
        } else if let Some(val) = line.strip_prefix("new file mode ") {
            let v = val.trim_end_matches('\r').trim_end();
            if v.is_empty() {
                return Err(Error::Message(format!(
                    "invalid mode on line {line_no}: {line}"
                )));
            }
            fp.is_new = true;
            fp.new_mode = Some(v.to_string());
            fp.new_mode_line = Some(line_no);
        } else if let Some(val) = line.strip_prefix("deleted file mode ") {
            let v = val.trim_end_matches('\r').trim_end();
            if v.is_empty() {
                return Err(Error::Message(format!(
                    "invalid mode on line {line_no}: {line}"
                )));
            }
            fp.is_deleted = true;
            fp.old_mode = Some(v.to_string());
            fp.old_mode_line = Some(line_no);
        } else if let Some(val) = line.strip_prefix("rename from ") {
            fp.is_rename = true;
            if let Some(p) = find_name_extended_header(val, p_extended) {
                fp.old_path = Some(p);
            }
        } else if let Some(val) = line.strip_prefix("rename to ") {
            fp.is_rename = true;
            if let Some(p) = find_name_extended_header(val, p_extended) {
                fp.new_path = Some(p);
            }
        } else if let Some(val) = line.strip_prefix("copy from ") {
            fp.is_copy = true;
            if let Some(p) = find_name_extended_header(val, p_extended) {
                fp.old_path = Some(p);
            }
        } else if let Some(val) = line.strip_prefix("copy to ") {
            fp.is_copy = true;
            if let Some(p) = find_name_extended_header(val, p_extended) {
                fp.new_path = Some(p);
            }
        } else if let Some(val) = line.strip_prefix("similarity index ") {
            fp.similarity_index = val.trim_end_matches('%').parse().ok();
        } else if let Some(val) = line.strip_prefix("dissimilarity index ") {
            fp.dissimilarity_index = val.trim_end_matches('%').parse().ok();
        } else if let Some(val) = line.strip_prefix("index ") {
            // Parse "index abc123..def456 100644" or "index abc123..def456"
            let mut parts = val.split_whitespace();
            let hash_part = parts.next().unwrap_or("");
            if let Some((old, new)) = hash_part.split_once("..") {
                fp.old_oid = Some(old.to_string());
                fp.new_oid = Some(new.to_string());
            }
            if let Some(mode_tok) = parts.next() {
                let v = mode_tok.trim_end_matches('\r').trim_end();
                if !v.is_empty() {
                    fp.old_mode = Some(v.to_string());
                    fp.old_mode_line = Some(line_no);
                }
            }
        } else if line == "GIT binary patch" {
            let (binary_patch, next_i) = parse_binary_patch(lines, i + 1)?;
            fp.binary_patch = Some(binary_patch);
            fp.is_binary = true;
            i = next_i;
            break;
        } else if line.starts_with("Binary files ") && line.ends_with(" differ") {
            // Plain (non --binary) diff of a binary change; no payload to
            // apply but stat/numstat must report it as binary.
            fp.is_binary = true;
        }
        // skip other extended headers
        i += 1;
    }

    if let Some(dn) = def_name {
        if fp.old_path.is_none() {
            fp.old_path = Some(dn.clone());
        }
        if fp.new_path.is_none() {
            fp.new_path = Some(dn);
        }
    }

    // Parse ---/+++ headers if present
    if i < lines.len() && lines[i].starts_with("--- ") {
        let old_p = lines[i]["--- ".len()..].trim_end_matches(['\r', '\n']);
        let old_b = old_p.as_bytes();
        if is_dev_null_nameline(old_b) {
            fp.old_path = Some("/dev/null".to_string());
        } else if let Some(p) = find_name_tab_terminated(old_b, p_strip) {
            fp.old_path = Some(bytes_to_path_string(&p)?);
        }
        fp.saw_old_header = true;
        i += 1;
        if i < lines.len() && lines[i].starts_with("+++ ") {
            let new_p = lines[i]["+++ ".len()..].trim_end_matches(['\r', '\n']);
            let new_b = new_p.as_bytes();
            if is_dev_null_nameline(new_b) {
                fp.new_path = Some("/dev/null".to_string());
            } else if let Some(p) = find_name_tab_terminated(new_b, p_strip) {
                fp.new_path = Some(bytes_to_path_string(&p)?);
            }
            fp.saw_new_header = true;
            i += 1;
        }
    }

    while i < lines.len() && lines[i].starts_with("index ") {
        let line = lines[i];
        let val = line["index ".len()..].trim_end();
        if let Some((old, new)) = val
            .split_whitespace()
            .next()
            .and_then(|h| h.split_once(".."))
        {
            fp.old_oid = Some(old.to_string());
            fp.new_oid = Some(new.to_string());
        }
        i += 1;
    }

    Ok((fp, i))
}

/// Parse a `GIT binary patch` payload.
fn parse_binary_patch(lines: &[&str], mut i: usize) -> Result<(BinaryPatchPayload, usize)> {
    let forward = parse_binary_section(lines, &mut i)?;
    let reverse = if i < lines.len()
        && (lines[i].starts_with("literal ") || lines[i].starts_with("delta "))
    {
        Some(parse_binary_section(lines, &mut i)?)
    } else {
        None
    };

    Ok((BinaryPatchPayload { forward, reverse }, i))
}

/// Parse one `literal <size>` or `delta <size>` block from a binary patch.
fn parse_binary_section(lines: &[&str], i: &mut usize) -> Result<BinaryPatchSection> {
    let header = lines.get(*i).copied().unwrap_or_default();
    let (kind, size_str) = if let Some(s) = header.strip_prefix("literal ") {
        (BinaryPatchSectionKind::Literal, s)
    } else if let Some(s) = header.strip_prefix("delta ") {
        (BinaryPatchSectionKind::Delta, s)
    } else {
        return Err(Error::Message(format!(
            "unsupported binary patch section: '{header}'"
        )));
    };
    let declared_size: usize = size_str
        .trim()
        .parse()
        .map_err(|e: std::num::ParseIntError| {
            Error::Message(format!("invalid binary patch section size: {e}"))
        })?;
    *i += 1;

    let mut compressed = Vec::new();
    while *i < lines.len() {
        let line = lines[*i];
        if line.is_empty() {
            *i += 1;
            break;
        }
        decode_binary_patch_line(line, &mut compressed)?;
        *i += 1;
    }

    Ok(BinaryPatchSection {
        kind,
        compressed,
        declared_size,
    })
}

/// Decode one binary patch payload line into compressed bytes.
fn decode_binary_patch_line(line: &str, out: &mut Vec<u8>) -> Result<()> {
    let mut chars = line.chars();
    let Some(len_ch) = chars.next() else {
        return Err(Error::Message(
            "empty binary patch payload line".to_string(),
        ));
    };
    let expected_len = decode_binary_line_len(len_ch)?;
    let body = chars.as_str().as_bytes();
    let decoded = crate::git_binary_base85::decode_body(body, expected_len)
        .map_err(|e| Error::Message(format!("invalid binary patch base85: {e}")))?;
    out.extend_from_slice(&decoded);
    Ok(())
}

fn decode_binary_line_len(ch: char) -> Result<usize> {
    if ch.is_ascii_uppercase() {
        return Ok((ch as u8 - b'A' + 1) as usize);
    }
    if ch.is_ascii_lowercase() {
        return Ok((ch as u8 - b'a' + 27) as usize);
    }
    Err(Error::Message(format!(
        "invalid binary patch line length marker: '{ch}'"
    )))
}

fn encode_binary_line_len(raw_len: usize) -> Result<char> {
    if raw_len == 0 || raw_len > 52 {
        return Err(Error::Message(format!(
            "binary patch line length out of range: {raw_len}"
        )));
    }
    let ch = if raw_len <= 26 {
        char::from(b'A' + (raw_len as u8) - 1)
    } else {
        char::from(b'a' + (raw_len as u8) - 27)
    };
    Ok(ch)
}

fn zlib_compress_binary_payload(data: &[u8]) -> Result<Vec<u8>> {
    use flate2::write::ZlibEncoder;
    use flate2::Compression;
    use std::io::Write;

    let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
    encoder
        .write_all(data)
        .map_err(|e| Error::Message(format!("zlib compress failed: {e}")))?;
    encoder
        .finish()
        .map_err(|e| Error::Message(format!("zlib compress finish failed: {e}")))
}

fn append_binary_literal_section(out: &mut String, uncompressed: &[u8]) -> Result<()> {
    let compressed = zlib_compress_binary_payload(uncompressed)?;
    out.push_str(&format!("literal {}\n", uncompressed.len()));
    for chunk in compressed.chunks(52) {
        let len_ch = encode_binary_line_len(chunk.len())?;
        let body = crate::git_binary_base85::encode(chunk);
        out.push_str(&format!("{len_ch}{body}\n"));
    }
    out.push('\n');
    Ok(())
}

/// Write the `GIT binary patch` body (literal forward then reverse) to `out`.
///
/// Forward literal is `new`; reverse literal is `old`, matching Git's `git diff --binary`.
/// The `index` line and `diff --git` header are the caller's responsibility.
pub fn write_git_binary_patch_sections<W: std::io::Write>(
    out: &mut W,
    old: &[u8],
    new: &[u8],
) -> Result<()> {
    out.write_all(b"GIT binary patch\n")
        .map_err(|e| Error::Message(format!("write binary patch header: {e}")))?;
    let mut buf = String::new();
    append_binary_literal_section(&mut buf, new)?;
    out.write_all(buf.as_bytes())
        .map_err(|e| Error::Message(format!("write binary patch forward: {e}")))?;
    buf.clear();
    append_binary_literal_section(&mut buf, old)?;
    out.write_all(buf.as_bytes())
        .map_err(|e| Error::Message(format!("write binary patch reverse: {e}")))?;
    Ok(())
}

/// Emit a unified diff whose body is a `GIT binary patch` with zlib+base85 literals.
///
/// Forward literal is `new`; reverse literal is `old`, matching Git's `git diff --binary`.
pub fn write_git_binary_patch(
    old: &[u8],
    new: &[u8],
    _old_path: &str,
    _new_path: &str,
) -> Result<String> {
    use crate::objects::{HashAlgo, ObjectKind};

    let old_oid = HashAlgo::Sha1.hash_object(ObjectKind::Blob, old)?;
    let new_oid = HashAlgo::Sha1.hash_object(ObjectKind::Blob, new)?;
    let mut out = String::with_capacity(old.len() + new.len() + 128);
    out.push_str(&format!(
        "index {}..{} 100644\n",
        old_oid.to_hex(),
        new_oid.to_hex()
    ));
    out.push_str("GIT binary patch\n");
    append_binary_literal_section(&mut out, new)?;
    append_binary_literal_section(&mut out, old)?;
    Ok(out)
}

/// Inflate zlib-compressed binary payload.
pub fn inflate_binary_payload(compressed: &[u8]) -> Result<Vec<u8>> {
    use flate2::read::ZlibDecoder;
    use std::io::Read;

    let mut decoder = ZlibDecoder::new(compressed);
    let mut out = Vec::new();
    decoder
        .read_to_end(&mut out)
        .map_err(|e| Error::Message(format!("failed to inflate binary patch payload: {e}")))?;
    Ok(out)
}

/// Expand one binary patch section to uncompressed bytes.
///
/// Delta sections require `base` (the preimage blob Git applies the delta against).
pub fn materialize_binary_patch_section(
    section: &BinaryPatchSection,
    base: Option<&[u8]>,
) -> Result<Vec<u8>> {
    let inflated = inflate_binary_payload(&section.compressed)?;
    match section.kind {
        BinaryPatchSectionKind::Literal => {
            if inflated.len() != section.declared_size {
                return Err(Error::Message(format!(
                    "binary patch literal size {} != declared {}",
                    inflated.len(),
                    section.declared_size
                )));
            }
            Ok(inflated)
        }
        BinaryPatchSectionKind::Delta => {
            let base = base.ok_or_else(|| {
                Error::Message("binary patch delta requires a base blob".to_string())
            })?;
            crate::unpack_objects::apply_delta(base, &inflated)
        }
    }
}

/// Reconstruct the post-image blob from the forward section and the old file contents.
pub fn materialize_binary_patch_forward(
    payload: &BinaryPatchPayload,
    old: &[u8],
) -> Result<Vec<u8>> {
    materialize_binary_patch_section(&payload.forward, Some(old))
}

/// Reconstruct the pre-image blob from the reverse section and the new file contents.
pub fn materialize_binary_patch_reverse(
    payload: &BinaryPatchPayload,
    new: &[u8],
) -> Result<Vec<u8>> {
    let reverse = payload
        .reverse
        .as_ref()
        .ok_or_else(|| Error::Message("binary patch has no reverse section".to_string()))?;
    materialize_binary_patch_section(reverse, Some(new))
}

/// Split the two path tokens from the remainder of a `diff --git` line (after `diff --git `).
fn split_diff_git_paths(s: &str) -> Option<(String, String)> {
    let s = s.trim_end_matches(['\r', '\n']);

    if s.as_bytes().first() == Some(&b'"') {
        let (first, rest_raw) = unquote_c_style_prefix(s)?;
        let rest = rest_raw.trim_start_matches(|c: char| c.is_ascii_whitespace());
        if rest.is_empty() {
            return None;
        }
        if rest.as_bytes().first() == Some(&b'"') {
            let (second, _) = unquote_c_style_prefix(rest)?;
            return Some((
                String::from_utf8_lossy(&first).into_owned(),
                String::from_utf8_lossy(&second).into_owned(),
            ));
        }
        let second = rest;
        if second.len() != first.len() || second.as_bytes() != first.as_slice() {
            return None;
        }
        return Some((
            String::from_utf8_lossy(&first).into_owned(),
            second.to_string(),
        ));
    }

    if let Some(pos) = s.find(" b/") {
        let a = &s[..pos];
        let b = &s[pos + 1..];
        return Some((a.to_string(), b.to_string()));
    }
    if s.starts_with("a/") {
        if let Some(pos) = s.find(" /dev/null") {
            let a = &s[..pos];
            return Some((a.to_string(), "/dev/null".to_string()));
        }
    }
    if let Some(b) = s.strip_prefix("/dev/null ") {
        return Some(("/dev/null".to_string(), b.to_string()));
    }

    let name = s.as_bytes();
    let line_len = name.len();
    let mut len = 0usize;
    while len < line_len {
        match name[len] {
            b'\n' => return None,
            b'\t' | b' ' => {
                if len + 1 > line_len {
                    return None;
                }
                let second = &name[len + 1..line_len];
                let names_match =
                    name.len() >= len && second.len() >= len && name[..len] == second[..len];
                let boundary_ok = second.get(len) == Some(&b'\n') || second.len() == len;
                if names_match && boundary_ok {
                    return Some((
                        String::from_utf8_lossy(&name[..len]).into_owned(),
                        String::from_utf8_lossy(second).into_owned(),
                    ));
                }
            }
            _ => {}
        }
        len += 1;
    }
    None
}

/// Parse a single hunk starting at line `i` (which should be an `@@` line).
fn parse_hunk(
    lines: &[&str],
    start: usize,
    input_name: &str,
    recount: bool,
) -> Result<(Hunk, usize)> {
    let header = lines[start];
    let (old_start, old_count, new_start, new_count) = parse_hunk_header(header)
        .map_err(|e| Error::Message(format!("invalid hunk header: {header}: {e}")))?;

    let mut hunk = Hunk {
        old_start,
        old_count,
        new_start,
        new_count,
        first_body_line: start + 2,
        lines: Vec::new(),
    };

    // Track how many old/new lines the body actually provides so a hunk that
    // ends prematurely is diagnosed like Git: "corrupt patch at <file>:<line>"
    // (t4012; Git parse_fragment returns -1 when oldlines/newlines remain).
    let mut old_seen = 0usize;
    let mut new_seen = 0usize;
    let mut i = start + 1;
    while i < lines.len() {
        let line = lines[i];
        if line.starts_with("@@ ") || line.starts_with("diff --git ") {
            break;
        }
        // `---` / `+++` with a space begin a new file header; do not treat `---` as a `-` hunk line
        // (would misparse `--- /dev/null` as a remove of `-- /dev/null` and merge the next file).
        if line.starts_with("--- ") || line.starts_with("+++ ") {
            break;
        }
        if line == "-- " {
            // format-patch signature separator; not part of hunk body
            break;
        }
        if let Some(rest) = line.strip_prefix('+') {
            hunk.lines.push(HunkLine::Add(rest.to_string()));
            new_seen += 1;
        } else if let Some(rest) = line.strip_prefix('-') {
            hunk.lines.push(HunkLine::Remove(rest.to_string()));
            old_seen += 1;
        } else if line.is_empty() {
            hunk.lines.push(HunkLine::Context(String::new()));
            old_seen += 1;
            new_seen += 1;
        } else if let Some(rest) = line.strip_prefix(' ') {
            // context line
            hunk.lines.push(HunkLine::Context(rest.to_string()));
            old_seen += 1;
            new_seen += 1;
        } else if line.starts_with('\\') {
            hunk.lines.push(HunkLine::NoNewline);
        } else {
            // Unknown line type — could be start of something else
            break;
        }
        i += 1;
    }

    if recount {
        hunk.old_count = old_seen;
        hunk.new_count = new_seen;
    } else if old_seen < old_count || new_seen < new_count {
        return Err(ApplyError::CorruptPatch {
            input: input_name.to_owned(),
            line: i + 1,
        }
        .into());
    }

    Ok((hunk, i))
}

/// Parse "@@ -old_start[,old_count] +new_start[,new_count] @@..."
fn parse_hunk_header(line: &str) -> Result<(usize, usize, usize, usize)> {
    // Find the range part between @@ markers
    let trimmed = line.trim_start_matches('@').trim_start();
    let end = trimmed.find(" @@").unwrap_or(trimmed.len());
    let range_part = &trimmed[..end];

    let parts: Vec<&str> = range_part.split_whitespace().collect();
    if parts.len() < 2 {
        return Err(Error::Message(
            "expected old and new range in hunk header".to_string(),
        ));
    }

    let (old_start, old_count) = parse_range(parts[0].trim_start_matches('-'))?;
    let (new_start, new_count) = parse_range(parts[1].trim_start_matches('+'))?;

    Ok((old_start, old_count, new_start, new_count))
}

/// Parse "N" or "N,M" into (start, count).
fn parse_range(s: &str) -> Result<(usize, usize)> {
    if let Some((start_s, count_s)) = s.split_once(',') {
        let start = start_s
            .parse::<usize>()
            .map_err(|e| Error::Message(e.to_string()))?;
        let count = count_s
            .parse::<usize>()
            .map_err(|e| Error::Message(e.to_string()))?;
        Ok((start, count))
    } else {
        let n: usize = s
            .parse()
            .map_err(|e: std::num::ParseIntError| Error::Message(e.to_string()))?;
        Ok((n, 1))
    }
}

mod blob_apply;
mod index_apply;

pub use blob_apply::{apply_patch_to_blob, BlobApplyOptions};
pub use index_apply::{
    apply_patch_to_index, apply_patch_to_index_and_write, IndexApplyOptions, IndexApplyOutcome,
};

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

    #[test]
    fn binary_bodies_resume_at_following_git_patch() {
        let old = b"before\0";
        let new = b"after\0";
        let body = write_git_binary_patch(old, new, "a/bin", "b/bin").expect("binary body");
        for (header, git_style) in [
            ("diff --git a/bin b/bin\n", true),
            ("diff --git a/bin b/bin\n--- a/bin\n+++ b/bin\n", true),
            ("--- a/bin\n+++ b/bin\n", false),
        ] {
            let input = format!(
                "{header}{body}diff --git a/text b/text\n--- a/text\n+++ b/text\n@@ -1 +1 @@\n-old\n+new\n"
            );
            let files = parse_patch(&input, 1, "mixed", false, None).expect("parse mixed patch");
            assert_eq!(files.len(), 2);
            let binary = &files[0];
            assert_eq!(binary.effective_path(), Some("bin"));
            assert_eq!(binary.is_toplevel_relative, git_style);
            assert_eq!(binary.old_oid.is_some(), git_style);
            assert!(binary.is_binary);
            assert!(binary.hunks.is_empty());
            let payload = binary.binary_patch.as_ref().expect("binary payload");
            assert_eq!(materialize_binary_patch_forward(payload, old).unwrap(), new);
            assert_eq!(materialize_binary_patch_reverse(payload, new).unwrap(), old);
            assert_eq!(files[1].effective_path(), Some("text"));
            assert!(files[1].is_toplevel_relative);
            assert!(!files[1].is_binary);
            assert_eq!(files[1].hunks.len(), 1);
            assert_eq!(files[1].hunks[0].first_body_line, input.lines().count() - 1);
        }
    }

    #[test]
    fn git_headers_keep_index_after_file_headers() {
        let input = "diff --git a/f b/f\nold mode 100644\nnew mode 100755\n\
                     --- a/f\n+++ b/f\nindex abc..def\nindex def..123\n";
        let files = parse_patch(input, 1, "modes", false, None).expect("parse headers");
        assert_eq!(files.len(), 1);
        assert_eq!(files[0].old_oid.as_deref(), Some("def"));
        assert_eq!(files[0].new_oid.as_deref(), Some("123"));
        assert_eq!(files[0].old_mode.as_deref(), Some("100644"));
        assert_eq!(files[0].new_mode.as_deref(), Some("100755"));
        assert_eq!(files[0].old_mode_line, Some(2));
        assert_eq!(files[0].new_mode_line, Some(3));
        assert!(files[0].saw_old_header && files[0].saw_new_header);
        assert!(files[0].hunks.is_empty());
    }

    #[test]
    fn corrupt_hunks_keep_line_numbers_for_both_header_styles() {
        for header in [
            "--- a/f\n+++ b/f\n",
            "diff --git a/f b/f\n--- a/f\n+++ b/f\n",
        ] {
            let input = format!("{header}@@ -1,3 +1,3 @@\n one\n");
            let err = parse_patch(&input, 1, "mixed", false, None).unwrap_err();
            assert!(matches!(
                err,
                Error::Apply(ApplyError::CorruptPatch { input, line })
                    if input == "mixed" && line == header.lines().count() + 3
            ));
        }
    }

    #[test]
    fn parses_simple_git_diff_into_one_file_patch() {
        let input = "diff --git a/foo.txt b/foo.txt\n\
                     index e69de29..d95f3ad 100644\n\
                     --- a/foo.txt\n\
                     +++ b/foo.txt\n\
                     @@ -0,0 +1 @@\n\
                     +hello\n";
        let patches = parse_patch(input, 1, "<test>", false, None).expect("parse");
        assert_eq!(patches.len(), 1);
        let fp = &patches[0];
        assert_eq!(fp.old_path.as_deref(), Some("foo.txt"));
        assert_eq!(fp.new_path.as_deref(), Some("foo.txt"));
        assert_eq!(fp.hunks.len(), 1);
        let hunk = &fp.hunks[0];
        assert_eq!(hunk.new_count, 1);
        assert!(matches!(hunk.lines.as_slice(), [HunkLine::Add(s)] if s == "hello"));
    }

    #[test]
    fn parses_new_file_mode_and_deletion() {
        let new_file = "diff --git a/n b/n\n\
                        new file mode 100644\n\
                        index 0000000..9daeafb\n\
                        --- /dev/null\n\
                        +++ b/n\n\
                        @@ -0,0 +1 @@\n\
                        +x\n";
        let patches = parse_patch(new_file, 1, "<test>", false, None).expect("parse");
        assert_eq!(patches.len(), 1);
        assert!(patches[0].is_new);
        assert_eq!(patches[0].new_mode.as_deref(), Some("100644"));

        let deleted = "diff --git a/d b/d\n\
                       deleted file mode 100644\n\
                       index 9daeafb..0000000\n\
                       --- a/d\n\
                       +++ /dev/null\n\
                       @@ -1 +0,0 @@\n\
                       -x\n";
        let patches = parse_patch(deleted, 1, "<test>", false, None).expect("parse");
        assert!(patches[0].is_deleted);
    }

    #[test]
    fn corrupt_hunk_is_reported_with_input_name_and_line() {
        // The body provides fewer lines than the header declares.
        let input = "--- a/x\n\
                     +++ b/x\n\
                     @@ -1,3 +1,3 @@\n\
                      one\n";
        let err = parse_patch(input, 1, "patch", false, None).unwrap_err();
        assert!(matches!(
            err,
            Error::Apply(ApplyError::CorruptPatch {
                ref input,
                line: 4
            }) if input == "patch"
        ));
        assert_eq!(
            err.git_stderr_message(),
            crate::diagnostics::error_line("corrupt patch at patch:4")
        );
    }

    #[test]
    fn parse_hunk_header_parses_ranges() {
        assert_eq!(parse_hunk_header("@@ -1,3 +2,4 @@").unwrap(), (1, 3, 2, 4));
        assert_eq!(parse_hunk_header("@@ -5 +6 @@ ctx").unwrap(), (5, 1, 6, 1));
    }

    #[test]
    fn invalid_hunk_header_chains_inner_message() {
        let err = parse_hunk_header("@@ -x +1 @@").unwrap_err();
        // The numeric parse failure must surface its own message.
        assert_eq!(err.to_string(), "invalid digit found in string");
    }

    #[cfg_attr(
        not(feature = "full-tests"),
        ignore = "starts system git or is heavy; run with --features full-tests"
    )]
    #[test]
    fn write_git_binary_patch_applies_with_system_git() {
        use std::fs;
        use std::process::Command;

        let old = b"\0BIN\0";
        let new = b"\0BIN2\0";
        let body = write_git_binary_patch(old, new, "a/b", "b/b").expect("write");
        let patch = format!("diff --git a/b b/b\n{body}");
        let dir = tempfile::tempdir().expect("tempdir");
        let b = dir.path().join("b");
        fs::write(&b, old).expect("write base");
        let patch_path = dir.path().join("p.diff");
        fs::write(&patch_path, &patch).expect("write patch");
        let check = Command::new("git")
            .current_dir(dir.path())
            .args(["apply", "--check", patch_path.to_str().expect("utf8")])
            .output()
            .expect("git apply --check");
        assert!(
            check.status.success(),
            "git apply --check rejected grit binary patch: {}",
            String::from_utf8_lossy(&check.stderr)
        );
        let apply = Command::new("git")
            .current_dir(dir.path())
            .args(["apply", patch_path.to_str().expect("utf8")])
            .output()
            .expect("git apply");
        assert!(apply.status.success(), "git apply failed");
        assert_eq!(fs::read(&b).expect("read"), new);
    }

    fn shattered_prefix_fixture() -> Vec<u8> {
        std::fs::read(
            std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
                .join("tests/data/shattered-1-prefix.bin"),
        )
        .expect("fixture")
    }

    #[test]
    fn apply_accepts_shattered_result_blob_like_git() {
        let shattered = shattered_prefix_fixture();
        let body = write_git_binary_patch(b"ok", &shattered, "a/f", "b/f").expect("binary patch");
        let patch = format!("diff --git a/f b/f\n{body}");
        let patches = parse_patch(&patch, 1, "p", false, None).expect("parse");
        let payload = patches[0].binary_patch.as_ref().expect("binary payload");
        let materialized =
            materialize_binary_patch_forward(payload, b"ok").expect("materialize shattered blob");
        assert_eq!(materialized, shattered);
    }

    #[test]
    fn write_git_binary_patch_roundtrips_through_parse_and_inflate() {
        let old = b"\0BIN\0";
        let new = b"\0BIN2\0";
        let body = write_git_binary_patch(old, new, "a/b", "b/b").expect("write");
        let patch = format!("diff --git a/b b/b\n{body}");
        assert!(patch.contains("GIT binary patch"));
        let patches = parse_patch(&patch, 1, "p", false, None).expect("parse");
        assert_eq!(patches.len(), 1);
        let payload = patches[0].binary_patch.as_ref().expect("binary payload");
        let forward = materialize_binary_patch_forward(payload, old).expect("materialize new");
        let reverse = materialize_binary_patch_reverse(payload, new).expect("materialize old");
        assert_eq!(forward, new);
        assert_eq!(reverse, old);
    }

    #[cfg_attr(
        not(feature = "full-tests"),
        ignore = "starts system git or is heavy; run with --features full-tests"
    )]
    #[test]
    fn git_produced_delta_binary_patch_parses_and_materializes() {
        use std::process::Command;

        let mut old = Vec::from(&b"\0BIN"[..]);
        old.extend((0u8..=255).cycle().take(996));
        assert_eq!(old.len(), 1000);
        let mut new = old.clone();
        new[500..510].copy_from_slice(b"CHANGED!!!");

        let dir = tempfile::tempdir().expect("tempdir");
        let old_path = dir.path().join("old.bin");
        let new_path = dir.path().join("new.bin");
        std::fs::write(&old_path, &old).expect("write old");
        std::fs::write(&new_path, &new).expect("write new");
        let out = Command::new("git")
            .args([
                "diff",
                "--no-index",
                "--binary",
                old_path.to_str().expect("utf8"),
                new_path.to_str().expect("utf8"),
            ])
            .output()
            .expect("git diff");
        assert!(
            out.status.code() == Some(1) || out.status.success(),
            "git diff failed: {}",
            String::from_utf8_lossy(&out.stderr)
        );
        let patch = String::from_utf8_lossy(&out.stdout);
        assert!(
            patch.contains("delta "),
            "expected git to emit delta sections: {patch}"
        );
        let patches = parse_patch(&patch, 1, "p", false, None).expect("parse git binary patch");
        let payload = patches[0].binary_patch.as_ref().expect("binary payload");
        assert_eq!(payload.forward.kind, BinaryPatchSectionKind::Delta);
        let got = materialize_binary_patch_forward(payload, &old).expect("apply forward delta");
        assert_eq!(got, new);
    }
}