//! The lines of an insert (spec §7.4) held as one buffer and where each

//! line ends, shared by the change and the file graph it builds: a tree of

//! forty million lines is then a few allocations per insert, not one per

//! line, and a graph's atoms point into their insert's buffer rather than

//! copying it.

use std::sync::Arc;

#[derive(Default, PartialEq, Eq, Hash)]

struct Inner {

    /// Shared with the file it was read from, when there was one.

    buf: Arc<Vec<u8>>,

    /// The end offset of each line in `buf`.

    ends: Vec<u64>,

}

/// An insert's lines. Cloning is cheap: the buffer is shared.

#[derive(Clone, Default, PartialEq, Eq, Hash)]

pub struct Lines(Arc<Inner>);

impl Lines {

    /// Lines from their bytes, each keeping its terminator; a final

    /// unterminated line is its own line (the rule of

    /// [`crate::diff::split_lines`]).

    pub fn split(content: &[u8]) -> Lines {

        Lines::split_shared(Arc::new(content.to_vec()))

    }

    /// [`Lines::split`] of a buffer held elsewhere too (a file's content),

    /// shared rather than copied.

    pub fn split_shared(buf: Arc<Vec<u8>>) -> Lines {

        let content = &buf[..];

        let mut ends = Vec::new();

        for (i, &c) in content.iter().enumerate() {

            if c == b'\n' {

                ends.push(i as u64 + 1);

            }

        }

        if ends.last().copied().unwrap_or(0) as usize != content.len() {

            ends.push(content.len() as u64);

        }

        Lines(Arc::new(Inner { buf, ends }))

    }

    pub fn len(&self) -> usize {

        self.0.ends.len()

    }

    pub fn is_empty(&self) -> bool {

        self.0.ends.is_empty()

    }

    /// Line `i`, with its terminator.

    pub fn get(&self, i: usize) -> Option<&[u8]> {

        let end = *self.0.ends.get(i)? as usize;

        let start = if i == 0 {

            0

        } else {

            self.0.ends[i - 1] as usize

        };

        Some(&self.0.buf[start..end])

    }

    pub fn iter(&self) -> impl ExactSizeIterator<Item = &[u8]> + Clone + '_ {

        (0..self.len()).map(move |i| self.get(i).unwrap())

    }

    /// Every line, joined: the bytes they were split from.

    pub fn bytes(&self) -> &[u8] {

        &self.0.buf

    }

    /// Whether splitting [`Lines::bytes`] by the line rule gives these lines

    /// back: every line but the last ends in a newline and none holds

    /// another. Every insert oxy makes is so, and such lines are stored as

    /// their bytes alone (spec §7.4).

    pub fn is_split_form(&self) -> bool {

        let buf = &self.0.buf;

        let mut start = 0usize;

        for (i, &end) in self.0.ends.iter().enumerate() {

            let line = &buf[start..end as usize];

            if line.is_empty() {

                return false;

            }

            let last = i + 1 == self.0.ends.len();

            let body = if last && !line.ends_with(b"\n") {

                line

            } else if line.ends_with(b"\n") {

                &line[..line.len() - 1]

            } else {

                return false;

            };

            if body.contains(&b'\n') {

                return false;

            }

            start = end as usize;

        }

        true

    }

    /// Lines `range` as lines of their own.

    pub fn slice(&self, range: std::ops::Range<usize>) -> Lines {

        self.iter().skip(range.start).take(range.len()).collect()

    }

    /// The lines as owned vectors, for code that edits them one by one.

    pub fn to_vec(&self) -> Vec<Vec<u8>> {

        self.iter().map(<[u8]>::to_vec).collect()

    }

}

impl std::ops::Index<usize> for Lines {

    type Output = [u8];

    fn index(&self, i: usize) -> &[u8] {

        self.get(i).expect("line index out of range")

    }

}

impl<'a> FromIterator<&'a [u8]> for Lines {

    fn from_iter<I: IntoIterator<Item = &'a [u8]>>(iter: I) -> Lines {

        let (mut buf, mut ends) = (Vec::new(), Vec::new());

        for l in iter {

            buf.extend_from_slice(l);

            ends.push(buf.len() as u64);

        }

        Lines(Arc::new(Inner {

            buf: Arc::new(buf),

            ends,

        }))

    }

}

impl FromIterator<Vec<u8>> for Lines {

    fn from_iter<I: IntoIterator<Item = Vec<u8>>>(iter: I) -> Lines {

        let (mut buf, mut ends) = (Vec::new(), Vec::new());

        for l in iter {

            buf.extend_from_slice(&l);

            ends.push(buf.len() as u64);

        }

        Lines(Arc::new(Inner {

            buf: Arc::new(buf),

            ends,

        }))

    }

}

impl From<Vec<Vec<u8>>> for Lines {

    fn from(v: Vec<Vec<u8>>) -> Lines {

        v.into_iter().collect()

    }

}

impl std::fmt::Debug for Lines {

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        f.debug_list()

            .entries(self.iter().map(String::from_utf8_lossy))

            .finish()

    }

}

/// One line of a [`Lines`], held by a file graph's atom.

#[derive(Clone, Debug, PartialEq, Eq)]

pub struct LineRef {

    lines: Lines,

    index: u32,

}

impl LineRef {

    pub fn new(lines: Lines, index: u32) -> LineRef {

        LineRef { lines, index }

    }

    pub fn bytes(&self) -> &[u8] {

        &self.lines[self.index as usize]

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn lines_split_index_and_join_as_the_line_rule_says() {

        for text in [&b""[..], b"a\n", b"a\nb", b"a\n\nb\n", b"\n", b"no end"] {

            let l = Lines::split(text);

            let want = crate::diff::split_lines(text);

            assert_eq!(l.len(), want.len(), "{text:?}");

            assert_eq!(l.iter().collect::<Vec<_>>(), want);

            assert_eq!(l.bytes(), text);

            let v: Lines = want.iter().copied().collect();

            assert_eq!(v, l);

            assert_eq!(Lines::from(l.to_vec()), l);

        }

        let l = Lines::split(b"a\nb\nc\n");

        assert!(l.is_split_form());

        assert!(!Lines::from(vec![b"a".to_vec(), b"b\n".to_vec()]).is_split_form());

        assert!(!Lines::from(vec![b"a\nb\n".to_vec()]).is_split_form());

        assert!(!Lines::from(vec![Vec::new()]).is_split_form());

        assert!(Lines::from(vec![b"a\n".to_vec(), b"end".to_vec()]).is_split_form());

        assert_eq!(&l[1], b"b\n");

        assert_eq!(

            l.slice(1..3).to_vec(),

            vec![b"b\n".to_vec(), b"c\n".to_vec()]

        );

        assert_eq!(LineRef::new(l.clone(), 2).bytes(), b"c\n");

    }

}