//! 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 {}; amend works on heads only (describe, split, and abandon work anywhere)", 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 _wc = self.lock_working_copy()?;

        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_history(&candidates)?;

        let new_heads = st.maximal(&candidates);

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

        let base = self.load_state_history(&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_history(&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 _wc = self.lock_working_copy()?;

        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_history(&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_history(&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 only `paths` of the working copy into the head it sits on

    /// (oxygen#118): they are committed as a change of their own, on the

    /// head, which is then squashed into it; the rest stays uncommitted

    /// work. A new `message` replaces the head's.

    pub fn amend_paths(&self, message: Option<&str>, paths: &[String]) -> Result<ChangeHash> {

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

        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;

        self.rewritable_head(&head)?;

        drop(snap);

        let (part, _) = self.commit_selection_partial(

            "oxy amend: the paths to fold in",

            &[head],

            &Selection::Paths(paths.to_vec()),

        )?;

        let folded = self.squash(&part, &head)?;

        match message {

            Some(m) => self.describe(&folded, m),

            None => Ok(folded),

        }

    }

    /// 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 {

            version: crate::objects::CHANGE_VERSION,

            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 _wc = self.lock_working_copy()?;

        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_history(&[*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,