//! Working-copy snapshots, commits, and the change builder (spec §12.3).

use super::*;

use crate::objects::AtomRef;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub enum ChangeStatus {

    Added,

    Modified,

    Removed,

    /// Moved from another path (detected by similarity, tracked as a placement change).

    Renamed,

    ModeChanged,

    /// The file is conflicted in the base state and still contains conflict markers.

    ConflictEdited,

    /// The file was conflicted in the base state and the working copy resolves it.

    Resolved,

}

/// Lines that mark a conflict region in a materialized file (spec §9.5).

pub fn has_conflict_markers(content: &[u8]) -> bool {

    split_lines(content).iter().any(|l| {

        l.starts_with(b"<<<<<<< oxy conflict") || l.starts_with(b"======= oxy conflict") || l.starts_with(b">>>>>>> oxy conflict")

    })

}

#[derive(Clone, Debug, PartialEq, Eq)]

pub struct PathStatus {

    pub path: String,

    pub status: ChangeStatus,

}

/// Operations of a change built from the working directory against a base.

pub(crate) struct BuiltChange {

    pub tree_ops: Vec<TreeOp>,

    pub edits: Vec<Edit>,

    pub contributors: Vec<ChangeHash>,

    pub resolves: bool,

    pub statuses: Vec<PathStatus>,

    /// The stored blob of every opaque path, for the manifest's stat cache.

    pub blobs: HashMap<String, ObjectRef>,

}

/// Result of snapshotting the working copy.

pub struct SnapshotResult {

    pub wc_hash: ChangeHash,

    pub wc: Change,

    /// The base state (closure of the working-copy change's dependencies).

    pub base: State,

    pub base_snapshot: Snapshot,

    pub statuses: Vec<PathStatus>,

    /// Whether the snapshot rewrote the working-copy change.

    pub changed: bool,

    /// Whether the working copy resolves conflicts of its base (spec §9.6).

    pub resolves: bool,

    /// Changes that contributed to the conflicts being resolved.

    pub contributors: Vec<ChangeHash>,

}

pub fn is_binary(content: &[u8]) -> bool {

    content[..content.len().min(BINARY_SNIFF)].contains(&0)

}

impl Repo {

    /// Diff the files on disk against `base` and build the operations of a

    /// change from `base` to the working directory. `reuse` maps paths to the

    /// NodeIds an earlier version of the same change assigned to new paths.

    pub(crate) fn build_against(&self, base: &State, base_snapshot: &Snapshot, reuse: HashMap<String, (NodeId, NodeKind)>) -> Result<BuiltChange> {

        let fs_entries = self.walk_working_copy_with(None, &Self::tracked_kinds(base_snapshot))?;

        self.build_from_entries(base, base_snapshot, reuse, &fs_entries)

    }

    /// Like `build_against`, for files given in memory (imports).

    pub(crate) fn build_from_entries(&self, base: &State, base_snapshot: &Snapshot, reuse: HashMap<String, (NodeId, NodeKind)>, fs_entries: &BTreeMap<String, FsEntry>) -> Result<BuiltChange> {

        // Attributes come from the files being committed, so a new

        // `.oxyattributes` applies to the same change that adds it.

        let attrs = crate::attributes::Attributes::from_files(

            fs_entries.iter().filter(|(p, _)| p.as_str() == ".oxyattributes" || p.ends_with("/.oxyattributes")).map(|(p, e)| (p.as_str(), e.content.as_slice())),

        );

        let mut b = ChangeBuilder::new(base, base_snapshot, reuse).with_attributes(attrs);

        // Rename detection (spec §7.1, §23): a removed file and an added file

        // of the same kind whose contents are at least half alike become one

        // move of the same node, so identity survives across the rename.

        let renames = detect_renames(base_snapshot, fs_entries, |p| self.in_scope(p));

        let renamed_from: HashMap<&str, &str> = renames.iter().map(|(old, new)| (new.as_str(), old.as_str())).collect();

        let renamed_to: HashMap<&str, &str> = renames.iter().map(|(old, new)| (old.as_str(), new.as_str())).collect();

        for (path, fs_entry) in fs_entries {

            match base_snapshot.files.get(path) {

                None => match renamed_from.get(path.as_str()) {

                    Some(old) => b.move_path(self, old, path, fs_entry, &base_snapshot.files[*old])?,

                    None => b.add_path(self, path, fs_entry)?,

                },

                Some(expected) => b.update_path(self, path, fs_entry, expected)?,

            }

        }

        for (path, expected) in &base_snapshot.files {

            if fs_entries.contains_key(path) || !self.in_scope(path) || renamed_to.contains_key(path.as_str()) {

                continue;

            }

            // A directory stays while anything under it exists or is out of scope.

            let still_needed = expected.kind == NodeKind::Dir

                && (fs_entries.keys().any(|p| p.starts_with(&format!("{path}/")))

                    || base_snapshot.files.keys().any(|p| p.starts_with(&format!("{path}/")) && !self.in_scope(p)));

            if !still_needed {

                b.remove_path(path, expected);

            }

        }

        let mut statuses = b.statuses;

        statuses.sort_by(|a, b| a.path.cmp(&b.path));

        Ok(BuiltChange { tree_ops: b.tree_ops, edits: b.edits, contributors: b.contributors.into_iter().collect(), resolves: b.resolves, statuses, blobs: b.blobs })

    }

    /// Store a change and, when `core.sign = change` and we are its author,

    /// sign it. A rewritten change by another author is stored unsigned: only

    /// its author (or a delegate) can vouch for it.

    pub(crate) fn store_signed(&self, change: &Change) -> Result<ChangeHash> {

        let ours = change.author == self.author();

        if self.config.sign_changes && ours && self.secret_key()?.is_none() {

            return fail("core.sign is \"change\" but no secret key is available for author.key");

        }

        let hash = self.store.put_change(change)?;

        if self.config.sign_changes && ours {

            self.sign_change(&hash)?;

        }

        Ok(hash)

    }

    /// Snapshot the working copy into the working-copy change (spec §12.3).

    pub fn snapshot(&self, command: &str) -> Result<SnapshotResult> {

        let _lock = self.lock_snapshot()?;

        let batch = self.store.begin_batch()?;

        let result = self.snapshot_locked(command);

        batch.finish()?;

        result

    }

    fn snapshot_locked(&self, command: &str) -> Result<SnapshotResult> {

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

        let (old_hash, old_wc) = self.working_copy()?;

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

        let base_snapshot = base.materialize();

        // Reuse the NodeIds the previous working-copy version assigned to new

        // paths, so an unchanged working copy hashes identically (spec §12.3).

        let reuse = added_node_paths(&old_wc, &base_snapshot);

        // The last manifest lets unchanged opaque files go unread.

        let manifest = self.read_manifest()?.map(|(_, _, m)| m);

        let fs_entries = self.walk_working_copy_with(manifest.as_ref(), &Self::tracked_kinds(&base_snapshot))?;

        let built = self.build_from_entries(&base, &base_snapshot, reuse, &fs_entries)?;

        let mut wc = Change {

            change_id: old_wc.change_id,

            deps: vec![],

            author: self.author(),

            hlc: old_wc.hlc,

            message: old_wc.message.clone(),

            tree_ops: built.tree_ops,

            edits: built.edits,

            kind: ChangeKind::WorkingCopy,

        };

        let base_heads = base.maximal(&old_wc.deps);

        let mut deps: BTreeSet<ChangeHash> = base_heads.into_iter().collect();

        deps.extend(referenced_changes(&wc, &base));

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

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

        wc.normalize();

        let resolves = built.resolves;

        let contributors = built.contributors;

        let statuses = built.statuses;

        // Empty snapshot: hash the candidate before storing; only record an op on change.

        let new_hash = wc.hash();

        let changed = new_hash != old_hash;

        if changed {

            self.store.put_change(&wc)?;

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

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

            self.record_op(&[op_ref], &format!("{command}{SNAPSHOT_SUFFIX}"), view)?;

        }

        // The prompt compares against this without recording anything.

        self.write_manifest_entries(base_snapshot.is_conflicted(), !wc.tree_ops.is_empty() || !wc.edits.is_empty(), &fs_entries, &built.blobs)?;

        Ok(SnapshotResult { wc_hash: new_hash, wc, base, base_snapshot, statuses, changed, resolves, contributors })

    }

    /// `oxy status --json` (spec §9.5): the changed paths and every conflict

    /// of the working copy's base with its kind, path, and contributing

    /// ChangeIds.

    pub fn status_json(&self, snap: &SnapshotResult) -> Result<String> {

        let heads = self.bookmark_heads()?;

        let base_snapshot = &snap.base_snapshot;

        let by_node = base_snapshot.tree.by_node();

        let path_of = |n: &NodeId| by_node.get(n).map(|e| e.path.clone());

        let id_of = |h: &ChangeHash| snap.base.get(h).map(|m| m.change_id.to_hex()).unwrap_or_else(|| h.to_hex());

        let paths = json_array(snap.statuses.iter().map(|s| format!("{{\"path\":{},\"status\":{}}}", json_str(&s.path), json_str(&format!("{:?}", s.status)))));

        let mut conflicts: Vec<String> = Vec::new();

        for (p, f) in &base_snapshot.files {

            if !f.is_conflicted() {

                continue;

            }

            let (kind, changes) = match &f.content {

                FileContent::Text { .. } => ("text", snap.base.conflict_regions(&f.node).contributors),

                FileContent::Opaque { blobs } => ("replace", snap.base.blob_contributors(&f.node, blobs)),

                FileContent::Dir => continue,

            };

            let resolved = match snap.statuses.iter().find(|s| s.path == *p).map(|s| s.status) {

                Some(ChangeStatus::Resolved) => "true",

                Some(ChangeStatus::ConflictEdited) => "\"markers\"",

                _ => "false",

            };

            conflicts.push(format!(

                "{{\"kind\":{},\"path\":{},\"node\":{},\"changes\":{},\"resolved\":{resolved}}}",

                json_str(kind),

                json_str(p),

                json_str(&f.node.to_hex()),

                json_array(changes.iter().map(|h| json_str(&id_of(h))))

            ));

        }

        for c in &base_snapshot.tree.conflicts {

            let (kind, nodes): (&str, Vec<NodeId>) = match c {

                crate::tree::TreeConflict::Name { nodes, .. } => ("name", nodes.clone()),

                crate::tree::TreeConflict::MultiPlacement { node, .. } => ("multi-placement", vec![*node]),

                crate::tree::TreeConflict::Orphan { node, .. } => ("orphan", vec![*node]),

                crate::tree::TreeConflict::Cycle { node } => ("cycle", vec![*node]),

                crate::tree::TreeConflict::Mode { node, .. } => ("mode", vec![*node]),

            };

            let detail = match c {

                crate::tree::TreeConflict::Name { name, parent, .. } => {

                    let dir = if *parent == NodeId::ROOT { String::new() } else { path_of(parent).unwrap_or_default() };

                    format!(",\"path\":{}", json_str(&if dir.is_empty() { name.clone() } else { format!("{dir}/{name}") }))

                }

                _ => nodes.first().and_then(path_of).map(|p| format!(",\"path\":{}", json_str(&p))).unwrap_or_default(),

            };

            conflicts.push(format!(

                "{{\"kind\":{},\"nodes\":{}{detail}}}",

                json_str(kind),

                json_array(nodes.iter().map(|n| json_str(&n.to_hex())))

            ));

        }

        Ok(format!(

            "{{\"bookmark\":{},\"working_copy\":{},\"heads\":{},\"clean\":{},\"conflicted\":{},\"paths\":{paths},\"conflicts\":{}}}",

            json_str(&self.config.bookmark),

            json_str(&snap.wc.change_id.to_hex()),

            heads.len(),

            snap.statuses.is_empty(),

            base_snapshot.is_conflicted(),

            json_array(conflicts)

        ))

    }

    /// Turn the working-copy change into a normal change on the bookmark (spec §12.3).

    pub fn commit(&self, message: &str, extra_deps: &[ChangeHash]) -> Result<ChangeHash> {

        self.commit_selection(message, extra_deps, &Selection::All)

    }

    /// The hunks of the working copy, for `oxy commit --interactive`: each

    /// tree operation and each edit, in the order `select_hunks` numbers them.

    pub fn hunks(&self) -> Result<(SnapshotResult, Vec<Hunk>)> {

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

        let hunks = render_hunks(&snap.wc, &snap.base, &snap.base_snapshot);

        Ok((snap, hunks))

    }

    /// Commit part of the working copy (spec §12.3). What is not selected

    /// stays on disk as uncommitted work: the next snapshot rebuilds it

    /// against the new base, so the working copy always describes the

    /// directory.

    pub fn commit_selection(&self, message: &str, extra_deps: &[ChangeHash], selection: &Selection) -> Result<ChangeHash> {

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

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

            return fail("nothing to commit: the working copy matches its base");

        }

        if let Some(s) = snap.statuses.iter().find(|s| s.status == ChangeStatus::ConflictEdited) {

            return fail(format!("{} still contains conflict markers", s.path));

        }

        if message.trim().is_empty() {

            return fail("a commit message is required");

        }

        let (tree_ops, edits, partial) = match selection {

            Selection::All => (snap.wc.tree_ops.clone(), snap.wc.edits.clone(), false),

            Selection::Paths(paths) => {

                let (o, e) = select_paths(&snap.wc, &snap.base_snapshot, paths);

                let partial = o.len() != snap.wc.tree_ops.len() || e.len() != snap.wc.edits.len();

                (o, e, partial)

            }

            Selection::Hunks(indices) => {

                let (o, e) = select_hunks(&snap.wc, indices);

                let partial = o.len() != snap.wc.tree_ops.len() || e.len() != snap.wc.edits.len();

                (o, e, partial)

            }

        };

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

            return fail("nothing selected to commit");

        }

        if partial && snap.resolves {

            return fail("a conflict resolution must be committed whole");

        }

        // pre-commit hook: may veto.

        self.run_hook(

            "pre-commit",

            &format!(

                "{{\"event\":\"pre-commit\",\"message\":{},\"paths\":{}}}",

                json_str(message),

                json_array(snap.statuses.iter().map(|s| format!("{{\"path\":{},\"status\":{}}}", json_str(&s.path), json_str(&format!("{:?}", s.status)))))

            ),

        )?;

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

        let mut deps: BTreeSet<ChangeHash> = referenced_changes(&snap.wc, &snap.base);

        // semantic-deps hook: may add explicit dependencies (spec §8.1).

        if self.config.semantic_deps {

            let touched: Vec<String> = snap.statuses.iter().map(|s| s.path.clone()).collect();

            let by_node = snap.base_snapshot.tree.by_node();

            let mut candidates: Vec<(ChangeId, ChangeHash, Vec<String>)> = Vec::new();

            let mut seen: BTreeSet<ChangeHash> = BTreeSet::new();

            for h in deps.iter().chain(snap.base.maximal(&snap.wc.deps).iter()) {

                if !seen.insert(*h) {

                    continue;

                }

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

                let mut paths: BTreeSet<String> = BTreeSet::new();

                for n in c.tree_ops.iter().map(|o| o.node()).chain(c.edits.iter().map(|e| e.node())) {

                    if let Some(e) = by_node.get(&n) {

                        paths.insert(e.path.clone());

                    }

                }

                candidates.push((c.change_id, *h, paths.into_iter().collect()));

            }

            for d in self.semantic_deps(&snap.wc.change_id, &touched, &candidates)? {

                if snap.base.contains(&d) {

                    deps.insert(d);

                }

            }

        }

        // A resolution depends on every change that contributed to the

        // conflict (spec §8.1). Tree and opaque conflicts are resolved through

        // ordinary operations whose references already cover the contributors.

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

        for d in extra_deps {

            if !snap.base.contains(d) {

                return fail(format!("--depends-on {d}: not in the working copy's base state"));

            }

            deps.insert(*d);

        }

        let mut change = Change {

            change_id: if partial { ChangeId::random() } else { snap.wc.change_id },

            deps: vec![],

            author: self.author(),

            hlc: Hlc::now(),

            message: message.trim_end().to_string(),

            tree_ops,

            edits,

            kind: if snap.resolves { ChangeKind::Resolution } else { ChangeKind::Normal },

        };

        if partial {

            // Dependencies come from what the selected part references, not

            // from the whole working copy.

            deps = referenced_changes(&change, &snap.base);

            for d in extra_deps {

                deps.insert(*d);

            }

        }

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

        change.normalize();

        let hash = self.store_signed(&change)?;

        // New bookmark heads: maximal elements of old heads plus the new change.

        // The working copy continues on its own base plus the new change, which

        // is exactly what the files on disk contain; the bookmark may hold

        // other heads (and conflicts) the working copy has not checked out.

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

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

        let mut all: Vec<ChangeHash> = old_heads.clone();

        all.extend(old_base.iter().copied());

        all.push(hash);

        let mut st = self.load_state(&all)?;

        st.add(change)?;

        let mut with_new = old_heads.clone();

        with_new.push(hash);

        let new_heads = st.maximal(&with_new);

        // Automatic checkpoint once enough changes accumulated (spec §11).

        let since = self.latest_checkpoint(&self.config.bookmark)?.map(|(_, cp)| cp.count).unwrap_or(0);

        if self.config.checkpoint_interval > 0 && (st.len() as u64).saturating_sub(since) >= self.config.checkpoint_interval {

            let cp_state = self.load_state_full(&new_heads)?;

            self.write_checkpoint(&self.config.bookmark, &cp_state, &new_heads)?;

        }

        let mut wc_base = old_base.clone();

        wc_base.push(hash);

        let wc_base = st.maximal(&wc_base);

        let wc = self.new_working_copy(wc_base, "");

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

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

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

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

        self.record_op(&[op_ref], &format!("oxy commit -m {message:?}"), view)?;

        if partial {