//! 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.

//! `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::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>> {

        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 rewritten = propagate(&state, *old, new, corr, &load).map_err(|e| RepoError::Msg(format!("{e}; rewriting through such references is not implemented yet")))?;

        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)

    }

    /// 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 that merely depend on it

    /// inherit its dependencies; one that references its atoms or placements

    /// cannot be rewritten yet. 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<()> {

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

        } else {

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

        }

        Ok(())

    }

}