//! History editing (spec §8.4): describe, amend, abandon.

//!

//! `describe` and `abandon` work on any change of the bookmark: dependents

//! are rewritten through `crate::rewrite`, with their references translated

//! and orphaned references reified as re-anchoring, reported as notes.

//! `amend` works on heads, where the amended change is rebuilt from the files

//! on disk. A rewritten change keeps its ChangeId and gets a new hash; old

//! objects stay in the store until garbage collection. Rewritten changes by

//! other authors lose their signatures, as with any rewrite of others' work.

use super::*;

use crate::objects::{AtomRange, AtomRef};

use crate::rewrite::{propagate, Correspondence};

impl Repo {

    /// The bookmark head `hash`, or an error explaining why it cannot be rewritten.

    fn rewritable_head(&self, hash: &ChangeHash) -> Result<Change> {

        let heads = self.bookmark_heads()?;

        if !heads.contains(hash) {

            return fail(format!(

                "change #{} is not a head of {}; rewriting changes that others depend on is not implemented yet",

                hash.short(12),

                self.config.bookmark

            ));

        }

        let c = self.store.get_change(hash)?;

        if c.kind == ChangeKind::WorkingCopy {

            return fail("that is the working copy; commit it instead");

        }

        Ok(c)

    }

    /// Replace head `old` with `new` (or with nothing) on the bookmark and

    /// restart the working copy on the resulting base. Files on disk are not

    /// touched: the next snapshot diffs them against the new base.

    fn replace_head(&self, old: &ChangeHash, new: Option<&Change>, command: &str) -> Result<Option<ChangeHash>> {

        let new_hash = match new {

            Some(c) => Some(self.store_signed(c)?),

            None => None,

        };

        let old_change = self.store.get_change(old)?;

        let (op_ref, op) = self.head_op()?;

        let bookmark = self.config.bookmark.clone();

        let heads = self.heads_of(&op.view, &bookmark)?;

        let replace = |set: &[ChangeHash]| -> Vec<ChangeHash> {

            let mut out: Vec<ChangeHash> = set.iter().filter(|h| *h != old).copied().collect();

            match new_hash {

                Some(n) => out.push(n),

                None => out.extend(old_change.deps.iter().copied()),

            }

            out

        };

        let candidates = replace(&heads);

        let st = self.load_state(&candidates)?;

        let new_heads = st.maximal(&candidates);

        let (_, wc) = self.working_copy()?;

        let base = self.load_state(&wc.deps)?;

        let wc_base = base.maximal(&wc.deps);

        let wc_base = if wc_base.contains(old) {

            let c = replace(&wc_base);

            let st = self.load_state(&c)?;

            st.maximal(&c)

        } else {

            wc_base

        };

        let fresh = self.new_working_copy(wc_base, &wc.message);

        let wc_hash = self.store.put_change(&fresh)?;

        let mut view = op.view.clone();

        view.bookmarks.insert(bookmark, self.store.put_state(&StateObject::new(new_heads))?);

        view.workspaces.insert(self.workspace, wc_hash);

        self.record_op(&[op_ref], command, view)?;

        self.drop_manifest();

        Ok(new_hash)

    }

    /// Replace `old` by `new` (or remove it) anywhere in the bookmark's state,

    /// rewriting every dependent, including the working copy. Returns the

    /// new hash of `old`, if any.

    fn rewrite_change(&self, old: &ChangeHash, new: Option<&Change>, corr: &Correspondence, command: &str) -> Result<Option<ChangeHash>> {

        self.rewrite_change_noted(old, new, corr, command).map(|(h, _)| h)

    }

    /// Like `rewrite_change`, also returning notes about reified references.

    fn rewrite_change_noted(&self, old: &ChangeHash, new: Option<&Change>, corr: &Correspondence, command: &str) -> Result<(Option<ChangeHash>, Vec<String>)> {

        let (op_ref, op) = self.head_op()?;

        let bookmark = self.config.bookmark.clone();

        let heads = self.heads_of(&op.view, &bookmark)?;

        let (wc_hash, _) = self.working_copy()?;

        let mut all = heads.clone();

        all.push(wc_hash);

        let state = self.load_state(&all)?;

        if !state.closure(&wc_hash).contains(old) && !heads.contains(old) && !state.heads().contains(old) && !state.contains(old) {

            return fail(format!("change #{} is not in {} or under the working copy", old.short(12), bookmark));

        }

        let old_change = self.store.get_change(old)?;

        if old_change.kind == ChangeKind::WorkingCopy {

            return fail("that is the working copy; commit it instead");

        }

        let load = |h: &ChangeHash| self.store.get_change(h).ok();

        let propagation = propagate(&state, *old, new, corr, &load).map_err(|e| RepoError::Msg(e.to_string()))?;

        let rewritten = propagation.changes;

        let mut mapping: HashMap<ChangeHash, ChangeHash> = HashMap::new();

        let new_hash = match new {

            Some(c) => {

                let h = self.store_signed(c)?;

                mapping.insert(*old, h);

                Some(h)

            }

            None => None,

        };

        for (h, c) in &rewritten {

            let nh = if c.kind == ChangeKind::WorkingCopy { self.store.put_change(c)? } else { self.store_signed(c)? };

            mapping.insert(*h, nh);

        }

        let remap = |set: &[ChangeHash]| -> Vec<ChangeHash> {

            let mut out = Vec::new();

            for h in set {

                if h == old && new_hash.is_none() {

                    out.extend(old_change.deps.iter().copied());

                } else {

                    out.push(*mapping.get(h).unwrap_or(h));

                }

            }

            out

        };

        let candidates = remap(&heads);

        let st = self.load_state(&candidates)?;

        let new_heads = st.maximal(&candidates);

        let new_wc = mapping.get(&wc_hash).copied().unwrap_or(wc_hash);

        let mut view = op.view.clone();

        view.bookmarks.insert(bookmark, self.store.put_state(&StateObject::new(new_heads))?);

        view.workspaces.insert(self.workspace, new_wc);

        self.record_op(&[op_ref], command, view)?;

        self.drop_manifest();

        Ok((new_hash, propagation.notes))

    }

    /// Change the message of any change of the bookmark; dependents are rewritten.

    pub fn describe(&self, hash: &ChangeHash, message: &str) -> Result<ChangeHash> {

        if message.trim().is_empty() {

            return fail("a message is required");

        }

        let mut c = self.store.get_change(hash)?;

        if c.kind == ChangeKind::WorkingCopy {

            return fail("that is the working copy; commit it instead");

        }

        if c.message == message.trim_end() {

            return Ok(*hash);

        }

        let corr = Correspondence::identity(&c);

        c.message = message.trim_end().to_string();

        c.hlc = Hlc::now();

        let id = c.change_id;

        Ok(self.rewrite_change(hash, Some(&c), &corr, &format!("oxy describe {} -m {message:?}", id.short(8)))?.unwrap())

    }

    /// Fold the working copy into the head it sits on: the head is rebuilt

    /// as the difference between the state beneath it and the files on disk.

    pub fn amend(&self, message: Option<&str>) -> Result<ChangeHash> {

        let snap = self.snapshot("oxy amend")?;

        if snap.statuses.iter().any(|s| s.status == ChangeStatus::ConflictEdited) {

            return fail("a file still contains conflict markers");

        }

        let base_heads = snap.base.maximal(&snap.wc.deps);

        let [head] = base_heads.as_slice() else {

            return fail(format!("the working copy sits on {} heads; check out the single change to amend", base_heads.len()));

        };

        let head = *head;

        let old = self.rewritable_head(&head)?;

        if snap.wc.tree_ops.is_empty() && snap.wc.edits.is_empty() && message.is_none() {

            return fail("nothing to amend: the working copy is clean and no new message was given");

        }

        // Rebuild against the state beneath the head.

        let beneath = self.load_state(&old.deps)?;

        let beneath_snapshot = beneath.materialize();

        let reuse = added_node_paths(&old, &beneath_snapshot);

        let built = self.build_against(&beneath, &beneath_snapshot, reuse)?;

        if built.tree_ops.is_empty() && built.edits.is_empty() {

            return fail("amending would leave the change empty; use `oxy abandon` to drop it");

        }

        let mut deps: BTreeSet<ChangeHash> = old.deps.iter().copied().collect();

        deps.extend(built.contributors.iter().copied());

        let mut new = Change {

            change_id: old.change_id,

            deps: vec![],

            author: self.author(),

            hlc: Hlc::now(),

            message: message.map(|m| m.trim_end().to_string()).unwrap_or(old.message.clone()),

            tree_ops: built.tree_ops,

            edits: built.edits,

            kind: if built.resolves || old.kind == ChangeKind::Resolution { ChangeKind::Resolution } else { ChangeKind::Normal },

        };

        deps.extend(referenced_changes(&new, &beneath));

        new.deps = deps.into_iter().collect();

        new.normalize();

        Ok(self.replace_head(&head, Some(&new), &format!("oxy amend {}", old.change_id.short(8)))?.unwrap())

    }

    /// Drop a change from the bookmark. Dependents inherit its dependencies;

    /// references into it are reified by re-anchoring (spec §8.4) and the

    /// adjustments are returned as notes. A dropped head's content stays on

    /// disk as uncommitted work if the working copy sat on it.

    pub fn abandon(&self, hash: &ChangeHash) -> Result<Vec<String>> {

        let c = self.store.get_change(hash)?;

        if c.kind == ChangeKind::WorkingCopy {

            return fail("that is the working copy; commit it instead");

        }

        let heads = self.bookmark_heads()?;

        if heads.contains(hash) {

            self.replace_head(hash, None, &format!("oxy abandon {}", c.change_id.short(8)))?;

            Ok(vec![])

        } else {

            let (_, notes) = self.rewrite_change_noted(hash, None, &Correspondence::default(), &format!("oxy abandon {}", c.change_id.short(8)))?;

            Ok(notes)

        }

    }

}

/// Translate a reference to change `target`'s own atom or op into a self

/// reference, and a working-copy self reference into one offset past the

/// target's own count; other references pass through.

fn fold_atom(r: AtomRef, target: &ChangeHash, wc_offset: &HashMap<NodeId, u32>, node: &NodeId) -> Option<AtomRef> {

    match r {

        AtomRef::Atom { change, index } if change == *target => Some(AtomRef::Atom { change: ObjectRef::ZERO, index }),

        AtomRef::Atom { change, index } if change.is_zero() => Some(AtomRef::Atom { change: ObjectRef::ZERO, index: index + wc_offset.get(node).copied().unwrap_or(0) }),

        // References into the target's closure were validated by the caller and stay as they are.

        other => Some(other),

    }

}

impl Repo {

    /// Fold the working copy's uncommitted edits into any change of the

    /// bookmark (spec §8.4). The edits must reference only atoms, placements

    /// and nodes that exist in the target's own closure; dependents are

    /// rewritten with an identity correspondence, since the target's own

    /// atoms keep their indices.

    pub fn amend_into(&self, target: &ChangeHash, message: Option<&str>) -> Result<ChangeHash> {

        let snap = self.snapshot("oxy amend")?;

        if snap.statuses.iter().any(|s| s.status == ChangeStatus::ConflictEdited) {

            return fail("a file still contains conflict markers");

        }

        let wc = &snap.wc;

        if wc.tree_ops.is_empty() && wc.edits.is_empty() && message.is_none() {

            return fail("nothing to amend: the working copy is clean and no new message was given");

        }

        let old = self.store.get_change(target)?;

        if old.kind == ChangeKind::WorkingCopy {

            return fail("that is the working copy; commit it instead");

        }

        // Every reference must live in the target's closure (or be the target).

        let closure = self.load_state(&[*target])?;

        let ok_change = |h: &ChangeHash| *h == *target || closure.contains(h);

        let ok_node = |n: &NodeId| n.is_root() || closure.tree().introducer(n).is_some();

        let too_new = |what: &str| RepoError::Msg(format!("{what} was introduced after change #{}; amend into a later change instead", target.short(12)));

        for op in &wc.tree_ops {

            match op {

                TreeOp::AddNode { parent, .. } => {

                    if !ok_node(parent) {

                        return Err(too_new("the parent directory"));

                    }

                }

                TreeOp::RemoveNode { node, placement } => {

                    if !ok_node(node) || !ok_change(&placement.change) {

                        return Err(too_new("a removed file"));

                    }

                }

                TreeOp::Move { node, old, parent, .. } => {

                    if !ok_node(node) || !ok_change(&old.change) || !ok_node(parent) {

                        return Err(too_new("a moved file"));

                    }

                }

                TreeOp::SetMode { node, old, .. } => {

                    if !ok_node(node) || !ok_change(&old.change) {

                        return Err(too_new("a file whose mode changed"));

                    }

                }

            }

        }

        let wc_added: BTreeSet<NodeId> = wc.tree_ops.iter().filter_map(|o| if let TreeOp::AddNode { node, .. } = o { Some(*node) } else { None }).collect();

        for e in &wc.edits {

            let n = e.node();

            if !wc_added.contains(&n) && !ok_node(&n) {

                return Err(too_new("an edited file"));

            }

            let refs: Vec<ChangeHash> = match e {

                Edit::Insert { after, before, .. } => [after, before].iter().filter_map(|r| if let AtomRef::Atom { change, .. } = r { Some(*change) } else { None }).collect(),

                Edit::Delete { atoms, .. } => atoms.iter().map(|r| r.change).collect(),

                Edit::Replace { .. } => vec![],

            };

            if refs.iter().any(|h| !h.is_zero() && !ok_change(h)) {

                return Err(too_new("an edited line"));

            }

        }

        // Compose: the target's operations first, then the working copy's

        // with references to the target turned into self references and its

        // own atom indices shifted past the target's.

        let mut per_node: HashMap<NodeId, u32> = HashMap::new();

        for e in &old.edits {

            if let Edit::Insert { node, lines, .. } = e {

                *per_node.entry(*node).or_default() += lines.len() as u32;

            }

        }

        let op_offset = old.tree_ops.len() as u32;

        let fold_op = |r: OpRef| -> OpRef {

            if r.change == *target {

                OpRef { change: ObjectRef::ZERO, index: r.index }

            } else if r.change.is_zero() {

                OpRef { change: ObjectRef::ZERO, index: r.index + op_offset }

            } else {

                r

            }

        };

        let mut tree_ops = old.tree_ops.clone();

        for op in &wc.tree_ops {

            tree_ops.push(match op {

                TreeOp::RemoveNode { node, placement } => TreeOp::RemoveNode { node: *node, placement: fold_op(*placement) },

                TreeOp::Move { node, old, parent, name } => TreeOp::Move { node: *node, old: fold_op(*old), parent: *parent, name: name.clone() },

                TreeOp::SetMode { node, old, mode } => TreeOp::SetMode { node: *node, old: fold_op(*old), mode: *mode },

                add => add.clone(),

            });

        }

        let mut edits = old.edits.clone();

        for e in &wc.edits {

            edits.push(match e {

                Edit::Insert { node, after, before, lines } => Edit::Insert {

                    node: *node,

                    after: fold_atom(*after, target, &per_node, node).ok_or_else(|| too_new("an anchor line"))?,

                    before: fold_atom(*before, target, &per_node, node).ok_or_else(|| too_new("an anchor line"))?,

                    lines: lines.clone(),

                },

                Edit::Delete { node, atoms } => Edit::Delete {

                    node: *node,

                    atoms: atoms

                        .iter()

                        .map(|r| {

                            if r.change == *target {

                                AtomRange { change: ObjectRef::ZERO, from: r.from, to: r.to }

                            } else if r.change.is_zero() {

                                let off = per_node.get(node).copied().unwrap_or(0);

                                AtomRange { change: ObjectRef::ZERO, from: r.from + off, to: r.to + off }

                            } else {

                                *r

                            }

                        })

                        .collect(),

                },

                other => other.clone(),

            });

        }

        let mut new = Change {

            change_id: old.change_id,

            deps: vec![],

            author: self.author(),

            hlc: Hlc::now(),

            message: message.map(|m| m.trim_end().to_string()).unwrap_or(old.message.clone()),

            tree_ops,

            edits,

            kind: old.kind,

        };

        let beneath = self.load_state(&old.deps)?;

        let mut deps: BTreeSet<ChangeHash> = old.deps.iter().copied().collect();

        deps.extend(referenced_changes(&new, &beneath).into_iter().filter(|h| *h != *target));

        deps.extend(wc.deps.iter().filter(|d| closure.contains(d) && **d != *target).copied());

        new.deps = deps.into_iter().collect();

        new.normalize();

        // Rewrite dependents (identity correspondence), then start a fresh,

        // empty working copy: its edits now live in the amended change.

        let corr = Correspondence::identity(&old);

        let new_hash = self.rewrite_change(target, Some(&new), &corr, &format!("oxy amend --into {}", old.change_id.short(8)))?.unwrap();

        let (op_ref, op) = self.head_op()?;

        let heads = self.heads_of(&op.view, &self.config.bookmark)?;

        let fresh = self.new_working_copy(heads, "");

        let wc_hash = self.store.put_change(&fresh)?;

        let mut view = op.view.clone();

        view.workspaces.insert(self.workspace, wc_hash);

        self.record_op(&[op_ref], "oxy amend (working copy)", view)?;

        self.drop_manifest();

        Ok(new_hash)

    }

    /// Split a head into two changes: one holding the head's effect on

    /// `paths`, the other the rest (keeping the head's ChangeId). The

    /// working copy is unaffected.

    pub fn split(&self, hash: &ChangeHash, paths: &[String]) -> Result<(ChangeHash, ChangeHash)> {

        let old = self.rewritable_head(hash)?;

        if paths.is_empty() {

            return fail("name at least one path to split out");

        }

        let beneath = self.load_state(&old.deps)?;

        let beneath_snapshot = beneath.materialize();

        let full = self.load_state(&[*hash])?;

        let full_snapshot = full.materialize();

        let selected = |p: &str| paths.iter().any(|x| p == x || p.starts_with(&format!("{}/", x.trim_end_matches('/'))));

        // Entries of the intermediate state: selected paths as the head

        // leaves them, everything else as beneath.

        let entries_of = |snap: &Snapshot, keep_from_full: &dyn Fn(&str) -> bool| -> Result<BTreeMap<String, FsEntry>> {

            let mut out = BTreeMap::new();