//! Turn a working-copy file into edits against the live atoms of a node.
//! Anchors follow the convention in spec §7.4: an insertion at old position
//! `i` is anchored after `old[i-1]` and before `old[i]`, both of which are
//! adjacent in the author's view.

use crate::graph::AtomKey;
use crate::ids::NodeId;
use crate::objects::{AtomRange, AtomRef, Edit};
use similar::{capture_diff_slices, Algorithm, DiffOp};

/// Split into lines, each keeping its terminator; a final unterminated line
/// is its own atom.
pub fn split_lines(b: &[u8]) -> Vec<&[u8]> {
    let mut out = Vec::new();
    let mut start = 0;
    for (i, &c) in b.iter().enumerate() {
        if c == b'\n' {
            out.push(&b[start..=i]);
            start = i + 1;
        }
    }
    if start < b.len() {
        out.push(&b[start..]);
    }
    out
}

/// Coalesce atom keys into half-open ranges of consecutive indices per change.
pub fn ranges(keys: &[AtomKey]) -> Vec<AtomRange> {
    let mut out: Vec<AtomRange> = Vec::new();
    for &(c, i) in keys {
        match out.last_mut() {
            Some(r) if r.change == c && r.to == i => r.to = i + 1,
            _ => out.push(AtomRange {
                change: c,
                from: i,
                to: i + 1,
            }),
        }
    }
    out
}

/// Edits that transform the live lines `old` of `node` into `new`.
pub fn text_edits(node: NodeId, old: &[(AtomKey, Vec<u8>)], new: &[u8]) -> Vec<Edit> {
    let old_lines: Vec<&[u8]> = old.iter().map(|(_, l)| l.as_slice()).collect();
    let new_lines = split_lines(new);
    let ops = capture_diff_slices(Algorithm::Myers, &old_lines, &new_lines);

    let anchor = |i: usize| -> (AtomRef, AtomRef) {
        let after = if i == 0 {
            AtomRef::Start
        } else {
            AtomRef::Atom {
                change: old[i - 1].0 .0,
                index: old[i - 1].0 .1,
            }
        };
        let before = if i >= old.len() {
            AtomRef::End
        } else {
            AtomRef::Atom {
                change: old[i].0 .0,
                index: old[i].0 .1,
            }
        };
        (after, before)
    };

    let mut deleted: Vec<AtomKey> = Vec::new();
    let mut inserts: Vec<Edit> = Vec::new();
    for op in ops {
        match op {
            DiffOp::Equal { .. } => {}
            DiffOp::Delete {
                old_index, old_len, ..
            } => {
                deleted.extend(old[old_index..old_index + old_len].iter().map(|(k, _)| *k));
            }
            DiffOp::Insert {
                old_index,
                new_index,
                new_len,
            } => {
                let (after, before) = anchor(old_index);
                inserts.push(Edit::Insert {
                    node,
                    after,
                    before,
                    lines: new_lines[new_index..new_index + new_len]
                        .iter()
                        .map(|l| l.to_vec())
                        .collect(),
                });
            }
            DiffOp::Replace {
                old_index,
                old_len,
                new_index,
                new_len,
            } => {
                deleted.extend(old[old_index..old_index + old_len].iter().map(|(k, _)| *k));
                let (after, before) = anchor(old_index);
                inserts.push(Edit::Insert {
                    node,
                    after,
                    before,
                    lines: new_lines[new_index..new_index + new_len]
                        .iter()
                        .map(|l| l.to_vec())
                        .collect(),
                });
            }
        }
    }
    let mut edits = Vec::new();
    if !deleted.is_empty() {
        edits.push(Edit::Delete {
            node,
            atoms: ranges(&deleted),
        });
    }
    edits.extend(inserts);
    edits
}

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

    fn h(n: u8) -> ObjectRef {
        ObjectRef([n; 32])
    }

    #[test]
    fn split_keeps_terminators() {
        assert_eq!(split_lines(b"a\nb\n"), vec![&b"a\n"[..], &b"b\n"[..]]);
        assert_eq!(split_lines(b"a\nb"), vec![&b"a\n"[..], &b"b"[..]]);
        assert_eq!(split_lines(b""), Vec::<&[u8]>::new());
        assert_eq!(split_lines(b"\n\n"), vec![&b"\n"[..], &b"\n"[..]]);
    }

    #[test]
    fn ranges_coalesce() {
        let r = ranges(&[(h(1), 0), (h(1), 1), (h(1), 3), (h(2), 0)]);
        assert_eq!(
            r,
            vec![
                AtomRange {
                    change: h(1),
                    from: 0,
                    to: 2
                },
                AtomRange {
                    change: h(1),
                    from: 3,
                    to: 4
                },
                AtomRange {
                    change: h(2),
                    from: 0,
                    to: 1
                }
            ]
        );
    }

    #[test]
    fn edits_for_typical_changes() {
        let node = NodeId::random();
        let old: Vec<(AtomKey, Vec<u8>)> = ["a\n", "b\n", "c\n"]
            .iter()
            .enumerate()
            .map(|(i, l)| ((h(1), i as u32), l.as_bytes().to_vec()))
            .collect();
        // No change.
        assert!(text_edits(node, &old, b"a\nb\nc\n").is_empty());
        // Replace middle line.
        let e = text_edits(node, &old, b"a\nB\nc\n");
        assert_eq!(
            e,
            vec![
                Edit::Delete {
                    node,
                    atoms: vec![AtomRange {
                        change: h(1),
                        from: 1,
                        to: 2
                    }]
                },
                Edit::Insert {
                    node,
                    after: AtomRef::Atom {
                        change: h(1),
                        index: 0
                    },
                    before: AtomRef::Atom {
                        change: h(1),
                        index: 1
                    },
                    lines: vec![b"B\n".to_vec()]
                },
            ]
        );
        // Prepend and append.
        let e = text_edits(node, &old, b"top\na\nb\nc\nend\n");
        assert_eq!(e.len(), 2);
        assert!(matches!(
            &e[0],
            Edit::Insert {
                after: AtomRef::Start,
                before: AtomRef::Atom { index: 0, .. },
                ..
            }
        ));
        assert!(matches!(
            &e[1],
            Edit::Insert {
                after: AtomRef::Atom { index: 2, .. },
                before: AtomRef::End,
                ..
            }
        ));
        // Delete everything.
        let e = text_edits(node, &old, b"");
        assert_eq!(
            e,
            vec![Edit::Delete {
                node,
                atoms: vec![AtomRange {
                    change: h(1),
                    from: 0,
                    to: 3
                }]
            }]
        );
        // From empty.
        let e = text_edits(node, &[], b"x\n");
        assert_eq!(
            e,
            vec![Edit::Insert {
                node,
                after: AtomRef::Start,
                before: AtomRef::End,
                lines: vec![b"x\n".to_vec()]
            }]
        );
    }
}