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

//!

//! Only heads can be rewritten so far. A head has no dependents, so

//! rewriting it needs no propagation; rewriting a change with dependents

//! (translating their atom and placement references) is not implemented.

//! The rewritten change keeps its ChangeId and gets a new hash; the old

//! object stays in the store until garbage collection.

use super::*;

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)?;

        Ok(new_hash)

    }

    /// Change the message of a head.

    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.rewritable_head(hash)?;

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

            return Ok(*hash);

        }

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

        c.hlc = Hlc::now();

        Ok(self.replace_head(hash, Some(&c), &format!("oxy describe {} -m {message:?}", c.change_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 head from the bookmark. Its content stays on disk as

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

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

        let c = self.rewritable_head(hash)?;

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

        Ok(())

    }

}