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

use super::*;

#[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()?;

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

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

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

        }

        // 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: snap.wc.change_id,

            deps: deps.into_iter().collect(),

            author: self.author(),

            hlc: Hlc::now(),

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

            tree_ops: snap.wc.tree_ops.clone(),

            edits: snap.wc.edits.clone(),

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

        };

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

        self.rewrite_manifest_flags(snap.base_snapshot.is_conflicted() && !snap.resolves, false)?;

        self.maybe_autopack()?;

        let _ = self.run_hook("post-commit", &format!("{{\"event\":\"post-commit\",\"change_id\":{},\"hash\":{},\"message\":{}}}", json_str(&snap.wc.change_id.to_hex()), json_str(&hash.to_hex()), json_str(message)));

        Ok(hash)

    }

}

/// Builds the tree ops and edits of a working-copy change against a base.

struct ChangeBuilder<'a> {

    base: &'a State,

    base_snapshot: &'a Snapshot,

    tree_ops: Vec<TreeOp>,

    edits: Vec<Edit>,

    statuses: Vec<PathStatus>,

    dir_nodes: HashMap<String, NodeId>,

    reuse: HashMap<String, (NodeId, NodeKind)>,

    /// Changes that contributed to conflicts this working copy resolves.

    contributors: BTreeSet<ChangeHash>,

    resolves: bool,

    attrs: crate::attributes::Attributes,

    blobs: HashMap<String, ObjectRef>,

}

impl<'a> ChangeBuilder<'a> {

    fn new(base: &'a State, base_snapshot: &'a Snapshot, reuse: HashMap<String, (NodeId, NodeKind)>) -> Self {

        let mut dir_nodes: HashMap<String, NodeId> = HashMap::new();

        dir_nodes.insert(String::new(), NodeId::ROOT);

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

            if f.kind == NodeKind::Dir {

                dir_nodes.insert(p.clone(), f.node);

            }

        }

        ChangeBuilder { base, base_snapshot, tree_ops: vec![], edits: vec![], statuses: vec![], dir_nodes, reuse, contributors: BTreeSet::new(), resolves: false, attrs: crate::attributes::Attributes::default(), blobs: HashMap::new() }

    }

    fn with_attributes(mut self, attrs: crate::attributes::Attributes) -> Self {

        self.attrs = attrs;

        self

    }

    /// Whether a file is opaque: forced by `binary`, forced text by `text`

    /// only when it has no NUL bytes, else sniffed.

    /// The blob for an opaque entry: the cached one, else stored now.

    fn blob_of(&mut self, repo: &Repo, path: &str, e: &FsEntry, nocompress: bool) -> Result<ObjectRef> {

        let b = match e.blob {

            Some(b) => b,

            None => repo.store_blob_for(&e.content, nocompress)?,

        };

        self.blobs.insert(path.to_string(), b);

        Ok(b)

    }

    fn opaque_for(&self, path: &str, e: &FsEntry) -> bool {

        if e.blob.is_some() {

            return true;

        }

        if e.kind == NodeKind::Symlink {

            return true;

        }

        match self.attrs.lookup(path).binary {

            Some(true) => true,

            Some(false) => is_binary(&e.content),

            None => is_binary(&e.content),

        }

    }

    /// Text content as stored: `\r\n` normalized for `eol=` files.

    fn stored_text(&self, path: &str, content: &[u8]) -> Vec<u8> {

        if self.attrs.lookup(path).eol.is_some() { crate::attributes::normalize_eol(content) } else { content.to_vec() }