//! Diff rendering: `oxy`'s per-file hunks become unified rows with
//! context, and two snapshots become per-file hunks.

use oxy_core::repo::{DiffHunk, FileDiff};
use oxy_core::state::{FileContent, Snapshot};
use similar::{Algorithm, DiffOp};
use std::collections::BTreeMap;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Kind {
    Context,
    Add,
    Del,
    /// Elided lines between hunks.
    Gap,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Line {
    pub kind: Kind,
    pub old_no: Option<u32>,
    pub new_no: Option<u32>,
    /// Raw text, not escaped.
    pub text: String,
}

impl Kind {
    pub fn class(self) -> &'static str {
        match self {
            Kind::Context => "ctx",
            Kind::Add => "add",
            Kind::Del => "del",
            Kind::Gap => "gap",
        }
    }

    pub fn sign(self) -> &'static str {
        match self {
            Kind::Context => " ",
            Kind::Add => "+",
            Kind::Del => "-",
            Kind::Gap => "…",
        }
    }
}

fn text(b: &[u8]) -> String {
    String::from_utf8_lossy(b).trim_end_matches(['\n', '\r']).to_string()
}

/// Unified rows for one file: `base` is the file before the change (empty
/// for an added file) and `hunks` come from `oxy diff`, whose `base_line`
/// is the 1-based line the additions follow (0 = before the first line).
pub fn unified(base: &[u8], hunks: &[DiffHunk], context: usize) -> Vec<Line> {
    let base_lines: Vec<String> = oxy_core::diff::split_lines(base).into_iter().map(text).collect();
    // Turn hunks into a per-old-line plan: removed set, and additions keyed
    // by the base line they follow.
    let mut removed = std::collections::HashSet::new();
    let mut added: BTreeMap<u32, Vec<String>> = BTreeMap::new();
    for h in hunks {
        for (line, _) in &h.removed {
            removed.insert(*line);
        }
        added.entry(h.base_line).or_default().extend(h.added.iter().map(|b| text(b)));
    }
    // Walk the base, emitting rows; then trim to context around changes.
    let mut rows: Vec<Line> = Vec::new();
    let mut new_no: u32 = 0;
    if let Some(lines) = added.get(&0) {
        for l in lines {
            new_no += 1;
            rows.push(Line { kind: Kind::Add, old_no: None, new_no: Some(new_no), text: l.clone() });
        }
    }
    for (i, l) in base_lines.iter().enumerate() {
        let old_no = i as u32 + 1;
        if removed.contains(&old_no) {
            rows.push(Line { kind: Kind::Del, old_no: Some(old_no), new_no: None, text: l.clone() });
        } else {
            new_no += 1;
            rows.push(Line { kind: Kind::Context, old_no: Some(old_no), new_no: Some(new_no), text: l.clone() });
        }
        if let Some(lines) = added.get(&old_no) {
            for a in lines {
                new_no += 1;
                rows.push(Line { kind: Kind::Add, old_no: None, new_no: Some(new_no), text: a.clone() });
            }
        }
    }
    // Any additions anchored past the end (defensive).
    for (anchor, lines) in &added {
        if *anchor as usize > base_lines.len() {
            for a in lines {
                new_no += 1;
                rows.push(Line { kind: Kind::Add, old_no: None, new_no: Some(new_no), text: a.clone() });
            }
        }
    }
    with_context(rows, context)
}

/// Keep `context` rows around every change, replacing longer runs with a gap.
fn with_context(rows: Vec<Line>, context: usize) -> Vec<Line> {
    let changed: Vec<bool> = rows.iter().map(|r| r.kind != Kind::Context).collect();
    let mut keep = vec![false; rows.len()];
    for (i, c) in changed.iter().enumerate() {
        if *c {
            let lo = i.saturating_sub(context);
            let hi = (i + context + 1).min(rows.len());
            for k in keep.iter_mut().take(hi).skip(lo) {
                *k = true;
            }
        }
    }
    let mut out = Vec::new();
    let mut gap = 0;
    for (row, k) in rows.into_iter().zip(keep) {
        if k {
            if gap > 0 {
                out.push(Line { kind: Kind::Gap, old_no: None, new_no: None, text: format!("{gap} unchanged lines") });
                gap = 0;
            }
            out.push(row);
        } else {
            gap += 1;
        }
    }
    if gap > 0 {
        out.push(Line { kind: Kind::Gap, old_no: None, new_no: None, text: format!("{gap} unchanged lines") });
    }
    out
}

/// Hunks between two texts, in `oxy diff`'s shape.
pub fn hunks_between(old: &[u8], new: &[u8]) -> Vec<DiffHunk> {
    let old_lines = oxy_core::diff::split_lines(old);
    let new_lines = oxy_core::diff::split_lines(new);
    let ops = similar::capture_diff_slices(Algorithm::Myers, &old_lines, &new_lines);
    let mut hunks: Vec<DiffHunk> = Vec::new();
    for op in ops {
        match op {
            DiffOp::Equal { .. } => {}
            DiffOp::Delete { old_index, old_len, .. } => {
                hunks.push(DiffHunk {
                    base_line: (old_index + old_len) as u32,
                    added: vec![],
                    removed: (old_index..old_index + old_len).map(|i| (i as u32 + 1, old_lines[i].to_vec())).collect(),
                });
            }
            DiffOp::Insert { old_index, new_index, new_len } => {
                hunks.push(DiffHunk {
                    base_line: old_index as u32,
                    added: (new_index..new_index + new_len).map(|i| new_lines[i].to_vec()).collect(),
                    removed: vec![],
                });
            }
            DiffOp::Replace { old_index, old_len, new_index, new_len } => {
                hunks.push(DiffHunk {
                    base_line: (old_index + old_len) as u32,
                    added: (new_index..new_index + new_len).map(|i| new_lines[i].to_vec()).collect(),
                    removed: (old_index..old_index + old_len).map(|i| (i as u32 + 1, old_lines[i].to_vec())).collect(),
                });
            }
        }
    }
    hunks
}

/// Every file that differs between two snapshots, with the base content
/// of files present in both (for context).
pub fn snapshot_diff(base: &Snapshot, head: &Snapshot) -> (Vec<FileDiff>, BTreeMap<String, Vec<u8>>) {
    let mut files = Vec::new();
    let mut bases = BTreeMap::new();
    let text_of = |f: &oxy_core::state::FileState| match &f.content {
        FileContent::Text { bytes, .. } => Some(bytes.clone()),
        _ => None,
    };
    for (path, hf) in &head.files {
        if hf.kind == oxy_core::objects::NodeKind::Dir {
            continue;
        }
        match base.files.get(path) {
            None => {
                let new = text_of(hf).unwrap_or_default();
                files.push(FileDiff { path: path.clone(), kind: "added".into(), hunks: hunks_between(b"", &new), from: None });
            }
            Some(bf) => {
                let (old, new) = (text_of(bf), text_of(hf));
                if old != new {
                    let old_b = old.clone().unwrap_or_default();
                    let hunks = hunks_between(&old_b, &new.unwrap_or_default());
                    if let Some(o) = old {
                        bases.insert(path.clone(), o);
                    }
                    files.push(FileDiff { path: path.clone(), kind: "modified".into(), hunks, from: None });
                } else if bf.mode != hf.mode {
                    files.push(FileDiff { path: path.clone(), kind: "mode".into(), hunks: vec![], from: None });
                }
            }
        }
    }
    for (path, bf) in &base.files {
        if bf.kind != oxy_core::objects::NodeKind::Dir && !head.files.contains_key(path) {
            let old = text_of(bf).unwrap_or_default();
            bases.insert(path.clone(), old.clone());
            files.push(FileDiff { path: path.clone(), kind: "removed".into(), hunks: hunks_between(&old, b""), from: None });
        }
    }
    files.sort_by(|a, b| a.path.cmp(&b.path));
    (files, bases)
}

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

    #[test]
    fn unified_rows_with_context() {
        let base = b"a\nb\nc\nd\ne\nf\ng\nh\n";
        let hunks = hunks_between(base, b"a\nb\nc\nX\ne\nf\ng\nh\nZ\n");
        let rows = unified(base, &hunks, 1);
        let s: Vec<String> = rows.iter().map(|r| format!("{}{}", r.kind.sign(), r.text)).collect();
        assert_eq!(s, ["…2 unchanged lines", " c", "-d", "+X", " e", "…2 unchanged lines", " h", "+Z"]);
        assert_eq!(rows[2].old_no, Some(4));
        assert_eq!(rows[3].new_no, Some(4));
        assert_eq!(rows.last().unwrap().new_no, Some(9));
    }

    #[test]
    fn added_file() {
        let hunks = hunks_between(b"", b"one\ntwo\n");
        let rows = unified(b"", &hunks, 3);
        assert_eq!(rows.iter().map(|r| r.kind).collect::<Vec<_>>(), [Kind::Add, Kind::Add]);
    }
}