//! Safe bindings to bdiff.c.

use crate::errors::HgError;
use std::marker::PhantomData;

/// A file split into lines, ready for diffing.
pub struct Lines<'a> {
    /// The array of lines, allocated by bdiff.c.
    /// Must never be mutated by Rust code apart from freeing it in `Drop`.
    array: *mut ffi::bdiff_line,
    /// Length of the array.
    len: u32,
    /// Lifetime of the source buffer, since array items store pointers.
    _lifetime: PhantomData<&'a [u8]>,
}

/// Splits `source` into lines that can be diffed.
pub fn split_lines(source: &[u8]) -> Result<Lines, HgError> {
    let mut array = std::ptr::null_mut();
    // Safety: The pointer and length are valid since they both come from
    // `source`, and the out pointer is non-null.
    let result = unsafe {
        ffi::bdiff_splitlines(
            source.as_ptr() as *const std::ffi::c_char,
            source.len() as isize,
            &mut array,
        )
    };
    match u32::try_from(result) {
        Ok(len) => {
            assert!(!array.is_null());
            Ok(Lines {
                array,
                len,
                _lifetime: PhantomData,
            })
        }
        Err(_) => {
            Err(HgError::abort_simple("bdiff_splitlines failed to allocate"))
        }
    }
}

impl<'a> Lines<'a> {
    /// Returns the number of lines.
    pub fn len(&self) -> usize {
        self.len as usize
    }

    /// Returns an iterator over the lines.
    pub fn iter(&self) -> LinesIter<'_, 'a> {
        LinesIter {
            lines: self,
            index: 0,
        }
    }
}

impl Drop for Lines<'_> {
    fn drop(&mut self) {
        // Safety: This is the only place that frees the array (no
        // double-free), and it's in a `Drop` impl (no use-after-free).
        unsafe {
            libc::free(self.array as *mut std::ffi::c_void);
        }
    }
}

// Safety: It is safe to send `Lines` to a different thread because
// `self.array` is never copied so only one thread will free it.
unsafe impl Send for Lines<'_> {}

// It is *not* safe to share `&Lines` between threads because `ffi::bdiff_diff`
// mutates lines by storing bookkeeping information in `n` and `e`.
static_assertions_next::assert_impl!(Lines<'_>: !Sync);

#[derive(Clone)]
pub struct LinesIter<'a, 'b> {
    lines: &'a Lines<'b>,
    index: usize,
}

impl<'b> Iterator for LinesIter<'_, 'b> {
    type Item = &'b [u8];

    fn next(&mut self) -> Option<Self::Item> {
        if self.index == self.lines.len() {
            return None;
        }
        // Safety: We just checked that the index has not reached the length.
        let line = unsafe { *self.lines.array.add(self.index) };
        self.index += 1;
        // Safety: We assume bdiff.c sets `l` and `len` correctly.
        Some(unsafe {
            std::slice::from_raw_parts(line.l as *const u8, line.len as usize)
        })
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let len = self.lines.len() - self.index;
        (len, Some(len))
    }
}

impl ExactSizeIterator for LinesIter<'_, '_> {}

/// A diff hunk comparing lines [a1,a2) in file A with lines [b1,b2) in file B.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct Hunk {
    /// Start line index in file A (inclusive).
    pub a1: u32,
    /// End line index in file A (exclusive).
    pub a2: u32,
    /// Start line index in file B (inclusive).
    pub b1: u32,
    /// End line index in file B (exclusive).
    pub b2: u32,
}

/// A list of matching hunks.
pub struct HunkList {
    /// The head of the linked list, allocated by bdiff.c.
    head: *mut ffi::bdiff_hunk,
    /// Length of the list.
    len: u32,
}

/// Returns a list of hunks that match in `a` and `b`.
pub fn diff(a: &Lines, b: &Lines) -> Result<HunkList, HgError> {
    let mut out = ffi::bdiff_hunk {
        a1: 0,
        a2: 0,
        b1: 0,
        b2: 0,
        next: std::ptr::null_mut(),
    };
    // Safety: We assume bdiff.c sets `array` and `len` correctly; and the
    // out pointer is non-null.
    let result = unsafe {
        ffi::bdiff_diff(a.array, a.len as i32, b.array, b.len as i32, &mut out)
    };
    match u32::try_from(result) {
        Ok(len) => Ok(HunkList {
            // Start with out.next because the first hunk is not meaningful and
            // is not included in len. This matches mercurial/cffi/bdiff.py.
            head: out.next,
            len,
        }),
        Err(_) => Err(HgError::abort_simple("bdiff_diff failed to allocate")),
    }
}

impl HunkList {
    /// Returns the number of hunks.
    pub fn len(&self) -> usize {
        self.len as usize
    }

    /// Returns an iterator over the hunks.
    pub fn iter(&self) -> HunkListIter {
        HunkListIter {
            // Safety: If `self.head` is null, this is safe. If non-null, then:
            // - We assume bdiff.c made it properly aligned.
            // - It's dereferenceable (any bit pattern is ok for `bdiff_hunk`).
            // - It won't be mutated because `HunkListIter` is tied to `&self`.
            next: unsafe { self.head.as_ref() },
            remaining: self.len(),
        }
    }
}

impl Drop for HunkList {
    fn drop(&mut self) {
        // Safety: This is the only place that frees `self.head` (no
        // double-free), and it's in a `Drop` impl (no use-after-free).
        unsafe {
            ffi::bdiff_freehunks(self.head);
        }
    }
}

pub struct HunkListIter<'a> {
    next: Option<&'a ffi::bdiff_hunk>,
    remaining: usize,
}

impl Iterator for HunkListIter<'_> {
    type Item = Hunk;

    fn next(&mut self) -> Option<Self::Item> {
        match self.next {
            Some(hunk) => {
                // Safety: Same reasoning as in `HunkList::iter`.
                self.next = unsafe { hunk.next.as_ref() };
                self.remaining -= 1;
                debug_assert_eq!(hunk.a2 - hunk.a1, hunk.b2 - hunk.b1);
                Some(Hunk {
                    a1: hunk.a1 as u32,
                    a2: hunk.a2 as u32,
                    b1: hunk.b1 as u32,
                    b2: hunk.b2 as u32,
                })
            }
            None => {
                assert_eq!(self.remaining, 0);
                None
            }
        }
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        (self.remaining, Some(self.remaining))
    }
}

impl ExactSizeIterator for HunkListIter<'_> {}

mod ffi {
    #![allow(non_camel_case_types)]

    use std::ffi::{c_char, c_int};

    #[repr(C)]
    #[derive(Debug, Copy, Clone)]
    pub struct bdiff_line {
        pub hash: c_int,
        pub n: c_int,
        pub e: c_int,
        pub len: isize,
        pub l: *const c_char,
    }

    #[repr(C)]
    #[derive(Debug, Copy, Clone)]
    pub struct bdiff_hunk {
        pub a1: c_int,
        pub a2: c_int,
        pub b1: c_int,
        pub b2: c_int,
        pub next: *mut bdiff_hunk,
    }

    #[link(name = "bdiff", kind = "static")]
    extern "C" {
        /// Splits `a` into lines. On success, stores a pointer to an array of
        /// lines in `*lr` and returns its length. On failure, returns
        /// -1. The caller is responsible for freeing the array.
        ///
        /// # Safety
        ///
        /// - `a` must point to an array of `len` chars.
        /// - `lr` must be non-null (but `*lr` can be null).
        pub fn bdiff_splitlines(
            a: *const c_char,
            len: isize,
            lr: *mut *mut bdiff_line,
        ) -> c_int;

        /// Diffs `a` and `b`. On success, stores the head of a linked list of
        /// hunks in `base->next` and returns its length. On failure, returns
        /// -1. The caller is responsible for `bdiff_freehunks(base->next)`.
        ///
        /// # Safety
        ///
        /// - `a` must point to an array of `an` lines.
        /// - `b` must point to an array of `bn` lines.
        /// - `base` must be non-null.
        pub fn bdiff_diff(
            a: *mut bdiff_line,
            an: c_int,
            b: *mut bdiff_line,
            bn: c_int,
            base: *mut bdiff_hunk,
        ) -> c_int;

        /// Frees the linked list of hunks `l`.
        ///
        /// # Safety
        ///
        /// - `l` must be non-null, not already freed, and not used after this.
        pub fn bdiff_freehunks(l: *mut bdiff_hunk);
    }
}

#[cfg(test)]
mod tests {
    fn split(a: &[u8]) -> Vec<&[u8]> {
        super::split_lines(a).unwrap().iter().collect()
    }

    fn diff(a: &[u8], b: &[u8]) -> Vec<(u32, u32, u32, u32)> {
        let la = super::split_lines(a).unwrap();
        let lb = super::split_lines(b).unwrap();
        let hunks = super::diff(&la, &lb).unwrap();
        hunks.iter().map(|h| (h.a1, h.a2, h.b1, h.b2)).collect()
    }

    #[test]
    fn test_split_lines() {
        assert_eq!(split(b""), [] as [&[u8]; 0]);
        assert_eq!(split(b"\n"), [b"\n"]);
        assert_eq!(split(b"\r\n"), [b"\r\n"]);
        assert_eq!(split(b"X\nY"), [b"X\n" as &[u8], b"Y"]);
        assert_eq!(split(b"X\nY\n"), [b"X\n" as &[u8], b"Y\n"]);
        assert_eq!(split(b"X\r\nY\r\n"), [b"X\r\n" as &[u8], b"Y\r\n"]);
    }

    #[test]
    fn test_diff_single_line() {
        assert_eq!(diff(b"", b""), &[(0, 0, 0, 0)]);
        assert_eq!(diff(b"x", b"x"), &[(0, 1, 0, 1), (1, 1, 1, 1)]);
        assert_eq!(diff(b"x", b"y"), &[(1, 1, 1, 1)]);
    }

    #[test]
    fn test_diff_multiple_lines() {
        assert_eq!(
            diff(
                b" line1 \n line2 \n line3 \n line4 \n REMOVED \n",
                b" ADDED \n line1 \n lined2_CHANGED \n line3 \n line4 \n"
            ),
            &[(0, 1, 1, 2), (2, 4, 3, 5), (5, 5, 5, 5)]
        );
    }
}