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

    /// The `.oxyattributes` in force on disk, from the files the walk read.

    pub(crate) attributes: crate::attributes::Attributes,

    /// Folders holding a repository of their own (`.git` or `.oxy`) that

    /// are not subrepos, so nothing in them is tracked (oxygen#43).

    pub untracked_nested: Vec<String>,

}

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 mut fs_entries =

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

        self.platform_normalize(&mut fs_entries, base_snapshot);

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

    }

    /// Read the working copy as the platform left it (spec §7.7): without

    /// executable bits a file keeps the bit it has in the base, and without

    /// symbolic links a plain file where the base has a symlink is that

    /// symlink, written out as its target, not a new file.

    fn platform_normalize(&self, entries: &mut BTreeMap<String, FsEntry>, base: &Snapshot) {

        let p = self.platform;

        if p.exec_bits && p.symlinks {

            return;

        }

        for (path, e) in entries.iter_mut() {

            let Some(f) = base.files.get(path) else {

                continue;

            };

            if !p.symlinks && f.kind == NodeKind::Symlink && e.kind == NodeKind::File {

                e.kind = NodeKind::Symlink;

                e.exec = false;

            }

            if !p.exec_bits && f.kind == NodeKind::File && e.kind == NodeKind::File {

                e.exec = f.mode.exec;

            }

        }

    }

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

        self.build_from_entries_resolving(base, base_snapshot, reuse, fs_entries, &HashSet::new())

    }

    /// Like `build_from_entries`, settling the replace conflicts of the

    /// opaque files in `resolve` to their content (spec §9.3, §9.6): a

    /// caller that knows the user chose it, such as the hub's resolver. A

    /// snapshot never settles one on its own, since a checkout writes one

    /// candidate at the path.

    pub(crate) fn build_from_entries_resolving(

        &self,

        base: &State,

        base_snapshot: &Snapshot,

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

        fs_entries: &BTreeMap<String, FsEntry>,

        resolve: &HashSet<String>,

    ) -> Result<BuiltChange> {

        self.build_from_entries_with(base, base_snapshot, reuse, fs_entries, resolve, None)

    }

    /// `build_from_entries` whose new nodes take identifiers derived from

    /// `seed` and their paths instead of random ones, so the same input

    /// always builds the same change (a Git import, spec §23).

    ///

    /// With `dir_needed`, the snapshot and entries hold only the paths the

    /// import touches (and the directories a removal may leave empty); a

    /// directory stays while `dir_needed` says the new tree has something

    /// under it.

    pub(crate) fn build_from_entries_seeded(

        &self,

        base: &State,

        base_snapshot: &Snapshot,

        fs_entries: &BTreeMap<String, FsEntry>,

        seed: [u8; 32],

        dir_needed: Option<&dyn Fn(&str) -> bool>,

    ) -> Result<BuiltChange> {

        self.build_from_entries_with(

            base,

            base_snapshot,

            HashMap::new(),

            fs_entries,

            &HashSet::new(),

            Some(Import { seed, dir_needed }),

        )

    }

    fn build_from_entries_with(

        &self,

        base: &State,

        base_snapshot: &Snapshot,

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

        fs_entries: &BTreeMap<String, FsEntry>,

        resolve: &HashSet<String>,

        import: Option<Import>,

    ) -> Result<BuiltChange> {

        let seed = import.as_ref().map(|i| i.seed);

        let dir_needed = import.and_then(|i| i.dir_needed);

        let mut laps = crate::timing::Laps::start();

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

        b.resolve = resolve.clone();

        b.node_seed = seed;

        laps.lap("build: builder");

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

        laps.lap("build: renames");

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

            }

        }

        laps.lap("build: paths");

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

        // scope: the directories above each such path, gathered once.

        let mut needed_dirs: HashSet<&str> = HashSet::new();

        fn parents_of<'a>(p: &'a str, set: &mut HashSet<&'a str>) {

            let mut end = p.len();

            while let Some(i) = p[..end].rfind('/') {

                if !set.insert(&p[..i]) {

                    break;

                }

                end = i;

            }

        }

        for p in fs_entries.keys() {

            parents_of(p, &mut needed_dirs);

        }

        for p in base_snapshot.files.keys() {

            if !self.in_scope(p) {

                parents_of(p, &mut needed_dirs);

            }

        }

        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;

            }

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

                && match dir_needed {

                    Some(f) => f(path),

                    None => needed_dirs.contains(path.as_str()),

                };

            if !still_needed {

                b.remove_path(path, expected);

            }

        }

        laps.lap("build: removals");

        if seed.is_some() {

            b.retire_stray_placements();

        }

        laps.lap("build: stray placements");

        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).

    /// The result carries the full base state and its whole rendering.

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

        self.snapshot_as(command, false, false)

    }

    /// Snapshot the working copy as [`Repo::snapshot`] does, for commands

    /// that need its statuses, conflicts and base history, and the graphs

    /// of the files it changes: status, log, show, commit, diff, hunks and

    /// discard. Text files known unchanged since the last manifest are

    /// neither read nor rendered: the result's `base` is a history-only

    /// state without their graphs, and its `base_snapshot` lists them in

    /// `unrendered` with empty bytes. They are never conflicted, and no

    /// change the working copy makes touches them.

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

        self.snapshot_as(command, true, false)

    }

    /// `snapshot_as`; `force_manifest` writes the manifest even where a

    /// status would not bother (an edited file is read next time whatever

    /// it says), for a commit, after which that file is unchanged.

    fn snapshot_as(

        &self,

        command: &str,

        partial: bool,

        force_manifest: bool,

    ) -> Result<SnapshotResult> {

        let _lock = self.lock_snapshot()?;

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

        let result = self.snapshot_locked(command, partial, force_manifest);

        batch.finish()?;

        result

    }

    fn snapshot_locked(

        &self,

        command: &str,

        partial: bool,

        force_manifest: bool,

    ) -> Result<SnapshotResult> {

        let _all = crate::timing::phase("snapshot");

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

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

        // The base's history first: its graph keys say which files the

        // manifest already knows equal to it.

        let mut base = {

            let _t = crate::timing::phase("snapshot: load base history");

            self.load_state_indexed(&old_wc.deps)?

        };

        let view = {

            let _t = crate::timing::phase("snapshot: tree view");

            base.tree().view()

        };

        let manifest = {

            let _t = crate::timing::phase("snapshot: read manifest");

            self.read_manifest()?.map(|(_, _, m)| m)

        };

        let tracked: BTreeMap<String, (NodeKind, Option<ObjectRef>)> = {

            let _t = crate::timing::phase("snapshot: tracked paths");

            let mut t = BTreeMap::new();

            for (p, e) in view.entries.iter() {

                if e.kind == NodeKind::Dir {

                    continue;

                }

                let blob = if e.kind != NodeKind::File || e.mode.opaque {

                    base.live_blobs(&e.node).first().copied()

                } else {

                    None

                };

                t.insert(p.clone(), (e.kind, blob));

            }

            t

        };

        // A text file's graph key, worked out when the walk asks for it.

        let key_of = |p: &str| -> Option<[u8; 32]> {

            let e = view.entries.get(p)?;

            if e.kind != NodeKind::File || e.mode.opaque {

                return None;

            }

            base.graph_key(&e.node)

        };

        let mut fs_entries = {

            let _t = crate::timing::phase("snapshot: read working copy");

            self.walk_working_copy_with(manifest.as_deref(), &tracked, Some(&key_of))?

        };

        // The keys of the files read, before building graphs drops them: a

        // file found equal to its base rendering keeps its key.

        let keys: HashMap<String, [u8; 32]> = fs_entries

            .iter()

            .filter(|(_, e)| !e.unchanged && e.kind == NodeKind::File)

            .filter_map(|(p, _)| Some((p.clone(), key_of(p)?)))

            .collect();

        let base_snapshot = {

            let _t = crate::timing::phase("snapshot: load and render base");

            if partial {

                let skip: HashSet<NodeId> = fs_entries

                    .iter()

                    .filter(|(_, e)| e.unchanged)

                    .filter_map(|(p, _)| view.entries.get(p).map(|e| e.node))

                    .collect();

                let need: Vec<NodeId> = view

                    .entries

                    .values()

                    .filter(|e| e.kind == NodeKind::File && !skip.contains(&e.node))

                    .map(|e| e.node)

                    .collect();

                {

                    let _t = crate::timing::phase("snapshot:   of which building graphs");

                    self.load_graphs_of(&mut base, &need)?;

                }

                let _t = crate::timing::phase("snapshot:   of which rendering");

                base.materialize_except(&skip)

            } else {

                self.load_all_graphs(&mut base)?;

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

        self.platform_normalize(&mut fs_entries, &base_snapshot);

        let built = {

            let _t = crate::timing::phase("snapshot: diff against base");

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

        };

        // Text files found equal to an unconflicted base rendering keep its

        // graph key, so the next snapshot need not read or render them.

        {

            let changed: HashSet<&str> = built.statuses.iter().map(|s| s.path.as_str()).collect();

            for (p, e) in fs_entries.iter_mut() {

                if e.unchanged || e.kind != NodeKind::File || changed.contains(p.as_str()) {

                    continue;

                }

                e.graph_key = match base_snapshot.files.get(p).map(|f| &f.content) {

                    Some(FileContent::Text {

                        bytes,

                        materialized,

                    }) if !materialized.is_conflicted() && *bytes == *e.content => {

                        keys.get(p).copied()

                    }

                    _ => None,

                };

            }

        }

        let mut wc = Change {

            version: crate::objects::CHANGE_VERSION,

            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 record = crate::timing::phase("snapshot: hash and record");

        // Encoded once, its texts stored a batch at a time as they are

        // made (a stored blob is not stored again); the change itself only

        // when it changed.

        let encoded = wc.encode_streaming(|batch| self.store.put_texts(&batch))?;

        let new_hash = crate::hash::hash_object(crate::hash::ObjectType::Change, &encoded);

        let changed = new_hash != old_hash;

        if changed {

            self.store.put(crate::hash::ObjectType::Change, &encoded)?;

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