//! Bookmarks (spec §10.1): named states, any number per repository, with a

//! current bookmark per workspace. Merging is the union of two bookmarks'

//! heads: no merge change, conflicts reified.

use super::*;

/// One bookmark as `oxy bookmark list` shows it.

#[derive(Clone, Debug)]

pub struct BookmarkInfo {

    pub name: String,

    pub heads: Vec<ChangeHash>,

    /// The workspace's current bookmark.

    pub current: bool,

    /// Changes ahead of / behind the default remote's copy, when tracked.

    pub ahead: Option<usize>,

    pub behind: Option<usize>,

}

#[derive(Clone, Debug)]

pub struct MergeReport {

    pub heads: Vec<ChangeHash>,

    pub changed: bool,

    pub checked_out: bool,

}

/// Bookmark and tag names (spec §10.1): UTF-8, 1–255 bytes, no control

/// characters, no leading `-`, and none of `..`, `//`, `@{`.

pub fn valid_reference_name(name: &str) -> bool {

    !name.is_empty()

        && name.len() <= 255

        && !name.starts_with('-')

        && !name.chars().any(|c| c.is_control())

        && !name.contains("..")

        && !name.contains("//")

        && !name.contains("@{")

        && name != "policy"

}

/// The remote bookmark `spec` names as `REMOTE/NAME`, if `view` has one:

/// the remote, the bookmark's name there, and its state. The longest

/// matching remote name wins, and a bookmark name may hold `/` itself.

pub fn remote_bookmark<'a>(view: &'a View, spec: &str) -> Option<(&'a str, &'a str, ObjectRef)> {

    view.remotes

        .iter()

        .filter_map(|(remote, bookmarks)| {

            let rest = spec.strip_prefix(remote.as_str())?.strip_prefix('/')?;

            let (name, state) = bookmarks.get_key_value(rest)?;

            Some((remote.as_str(), name.as_str(), *state))

        })

        .max_by_key(|(remote, _, _)| remote.len())

}

/// A bookmark a remote has and this repository has no bookmark for.

#[derive(Clone, Debug)]

pub struct RemoteOnlyBookmark {

    pub remote: String,

    pub name: String,

    pub heads: Vec<ChangeHash>,

}

/// What one state lacks of another: see [`Repo::state_gap`].

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

pub struct StateGap {

    /// Changes of the first state recorded before the latest head of the

    /// second but not in it, oldest first: what Git's ancestry would have

    /// included.

    pub earlier: Vec<ChangeHash>,

    /// How many changes of the first state the second lacks altogether.

    pub lacks: usize,

    /// The heads of the second state together with `earlier`: everything

    /// of the first state up to the second's latest head.

    pub upto: Vec<ChangeHash>,

}

impl Repo {

    pub(crate) fn workspace_bookmark_path(&self) -> PathBuf {

        self.oxy

            .join("workspaces")

            .join(self.workspace.to_hex())

            .join("bookmark")

    }

    /// The remote a command uses when none is named: `origin`, else the

    /// only remote there is (finding 29 of the metalgear feedback: a

    /// checkout whose one remote is `earth`).

    pub fn default_remote(&self) -> String {

        match self.config.remotes.keys().collect::<Vec<_>>().as_slice() {

            [only] if *only != "origin" => (*only).clone(),

            _ => "origin".into(),

        }

    }

    /// How bookmark `name` stands against `remote`'s copy of it: the

    /// changes only here and only there. `None` when either side has no

    /// such bookmark.

    pub fn tracking(&self, remote: &str, name: &str) -> Result<Option<(usize, usize)>> {

        let view = self.view()?;

        let (Some(st), Some(rs)) = (

            view.bookmarks.get(name),

            view.remotes.get(remote).and_then(|b| b.get(name)),

        ) else {

            return Ok(None);

        };

        let heads = self.store.get_state(st)?.heads;

        let remote_heads = self.store.get_state(rs)?.heads;

        Ok(Some((

            self.negotiate(&remote_heads, &heads)?.len(),

            self.negotiate(&heads, &remote_heads)?.len(),

        )))

    }

    /// Every bookmark with its heads and its difference from the default

    /// remote's copy.

    pub fn bookmarks(&self) -> Result<Vec<BookmarkInfo>> {

        let view = self.view()?;

        let remote = self.default_remote();

        let mut out = Vec::new();

        for (name, st) in &view.bookmarks {

            let heads = self.store.get_state(st)?.heads;

            let (ahead, behind) = match view.remotes.get(&remote).and_then(|b| b.get(name)) {

                Some(rs) => {

                    let remote_heads = self.store.get_state(rs)?.heads;

                    (

                        self.negotiate(&remote_heads, &heads).map(|v| v.len()).ok(),

                        self.negotiate(&heads, &remote_heads).map(|v| v.len()).ok(),

                    )

                }

                None => (None, None),

            };

            out.push(BookmarkInfo {

                name: name.clone(),

                heads,

                current: *name == self.config.bookmark,

                ahead,

                behind,

            });

        }

        Ok(out)

    }

    /// Bookmarks of remotes with no local bookmark of the same name, by

    /// remote then name.

    pub fn remote_only_bookmarks(&self) -> Result<Vec<RemoteOnlyBookmark>> {

        let view = self.view()?;

        let mut out = Vec::new();

        for (remote, bookmarks) in &view.remotes {

            for (name, st) in bookmarks {

                if view.bookmarks.contains_key(name) {

                    continue;

                }

                out.push(RemoteOnlyBookmark {

                    remote: remote.clone(),

                    name: name.clone(),

                    heads: self.store.get_state(st)?.heads,

                });

            }

        }

        Ok(out)

    }

    /// The local bookmark to switch to for `spec`, creating it from a

    /// remote's when there is none (as `git switch` does): `NAME` takes

    /// `origin/NAME` (or the one remote that has it), and `REMOTE/NAME`

    /// takes that one. Returns the local name and, when it was just

    /// created, the remote it came from. A local bookmark tracks the

    /// remote's of the same name: `oxy pull` updates it.

    pub fn local_bookmark_for(&self, spec: &str) -> Result<(String, Option<String>)> {

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

        if op.view.bookmarks.contains_key(spec) {

            return Ok((spec.to_string(), None));

        }

        let (remote, name, state) = match remote_bookmark(&op.view, spec) {

            Some((remote, name, state)) => (remote.to_string(), name.to_string(), state),

            None => {

                let mut having: Vec<&String> = op

                    .view

                    .remotes

                    .iter()

                    .filter(|(_, b)| b.contains_key(spec))

                    .map(|(r, _)| r)

                    .collect();

                if let Some(i) = having.iter().position(|r| *r == "origin") {

                    having = vec![having[i]];

                }

                match having.as_slice() {

                    [] => return fail(format!("no bookmark {spec}, here or on a remote")),

                    [r] => {

                        let state = op.view.remotes[*r][spec];

                        (r.to_string(), spec.to_string(), state)

                    }

                    several => {

                        let names: Vec<String> =

                            several.iter().map(|r| format!("{r}/{spec}")).collect();

                        return fail(format!(

                            "several remotes have {spec}: name one, as {}",

                            names.join(" or ")

                        ));

                    }

                }

            }

        };

        if op.view.bookmarks.contains_key(&name) {

            // REMOTE/NAME where NAME is already local: switch to the local one.

            return Ok((name, None));

        }

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

        view.bookmarks.insert(name.clone(), state);

        self.record_op(

            &[op_ref],

            &format!("oxy bookmark track {remote}/{name}"),

            view,

        )?;

        Ok((name, Some(remote)))

    }

    /// Create `name` at `heads` (default: the working copy's base heads).

    pub fn bookmark_create(

        &self,

        name: &str,

        heads: Option<&[ChangeHash]>,

    ) -> Result<Vec<ChangeHash>> {

        if !valid_reference_name(name) {

            return fail(format!("{name:?} is not a valid bookmark name"));

        }

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

        if op.view.bookmarks.contains_key(name) {

            return fail(format!("bookmark {name} already exists"));

        }

        let heads = match heads {

            Some(h) => self.load_state_history(h)?.maximal(h),

            None => {

                let (_, wc) = self.working_copy()?;

                self.load_state_history(&wc.deps)?.maximal(&wc.deps)

            }

        };

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

        view.bookmarks.insert(

            name.to_string(),

            self.store.put_state(&StateObject::new(heads.clone()))?,

        );

        self.record_op(&[op_ref], &format!("oxy bookmark create {name}"), view)?;

        Ok(heads)

    }

    /// What a state at `at` lacks of the state at `from` (spec §10.1). A

    /// state is its heads and what they depend on, not everything recorded

    /// before them, so a bookmark created at one change of a state with

    /// several heads holds much less than someone used to Git expects.

    pub fn state_gap(&self, from: &[ChangeHash], at: &[ChangeHash]) -> Result<StateGap> {

        let mut all = from.to_vec();

        all.extend_from_slice(at);

        let st = self.load_state_history(&all)?;

        let with_closure = |hs: &[ChangeHash]| {

            let mut s: HashSet<ChangeHash> = hs.iter().copied().collect();

            for h in hs {

                s.extend(st.closure(h).iter().copied());

            }

            s

        };

        let from_set = with_closure(from);

        let at_set = with_closure(at);

        let key = |h: &ChangeHash| st.get(h).map(|m| (m.hlc, *h));

        let last = at.iter().filter_map(key).max();

        let missing: Vec<ChangeHash> = from_set

            .iter()

            .filter(|h| !at_set.contains(h))

            .copied()

            .collect();

        let mut earlier: Vec<ChangeHash> = missing

            .iter()

            .filter(|h| matches!((key(h), last), (Some(k), Some(l)) if k < l))

            .copied()

            .collect();

        earlier.sort_by_key(key);

        let mut candidates = at.to_vec();

        candidates.extend_from_slice(&earlier);

        Ok(StateGap {

            lacks: missing.len(),

            upto: st.maximal(&candidates),

            earlier,

        })

    }

    /// Point an existing bookmark at `heads`.

    pub fn bookmark_set(&self, name: &str, heads: &[ChangeHash]) -> Result<Vec<ChangeHash>> {

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

        if !op.view.bookmarks.contains_key(name) {

            return fail(format!(

                "no bookmark {name}; create it with `oxy bookmark create`"

            ));

        }

        let heads = self.load_state_history(heads)?.maximal(heads);

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

        view.bookmarks.insert(

            name.to_string(),

            self.store.put_state(&StateObject::new(heads.clone()))?,

        );

        self.record_op(&[op_ref], &format!("oxy bookmark set {name}"), view)?;

        if name == self.config.bookmark {

            self.drop_manifest();

        }

        Ok(heads)

    }

    /// Remove a bookmark; its changes stay until unreachable (spec §21).

    pub fn bookmark_delete(&self, name: &str) -> Result<()> {

        if name == self.config.bookmark {

            return fail(format!(

                "{name} is this workspace's current bookmark; switch to another first"

            ));

        }

        for w in self.workspaces()? {

            if !w.current && self.workspace_bookmark_of(&w.id).as_deref() == Some(name) {

                return fail(format!(

                    "{name} is the current bookmark of workspace {} at {}",

                    w.id.short(8),

                    w.path.display()

                ));

            }

        }

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

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

        if view.bookmarks.remove(name).is_none() {

            return fail(format!("no bookmark {name}"));

        }

        self.record_op(&[op_ref], &format!("oxy bookmark delete {name}"), view)?;

        Ok(())

    }

    fn workspace_bookmark_of(&self, id: &WorkspaceId) -> Option<String> {

        fs::read_to_string(

            self.oxy

                .join("workspaces")

                .join(id.to_hex())

                .join("bookmark"),

        )

        .ok()

        .map(|s| s.trim().to_string())

        .filter(|s| !s.is_empty())

    }

    /// Make `name` this workspace's current bookmark and check it out.

    pub fn bookmark_switch(&mut self, name: &str, discard: bool) -> Result<CheckoutReport> {

        let _wc = self.lock_working_copy()?;

        let (name, _) = self.local_bookmark_for(name)?;

        let name = name.as_str();

        let view = self.view()?;

        let Some(st) = view.bookmarks.get(name) else {

            return fail(format!("no bookmark {name}"));

        };

        let heads = self.store.get_state(st)?.heads;

        let report = self.checkout(&heads, discard, &format!("oxy bookmark switch {name}"))?;

        fs::create_dir_all(self.workspace_bookmark_path().parent().unwrap())?;

        write_atomic(&self.workspace_bookmark_path(), name.as_bytes())?;

        self.config.bookmark = name.to_string();

        Ok(report)

    }

    /// Switch to `name` taking uncommitted work along (spec §10.1), as `git

    /// switch` does: see [`Repo::checkout_carry`]. Returns the checkout

    /// report and the carried paths.

    pub fn bookmark_switch_carry(&mut self, name: &str) -> Result<(CheckoutReport, Vec<String>)> {

        let _wc = self.lock_working_copy()?;

        let (name, _) = self.local_bookmark_for(name)?;

        let name = name.as_str();

        let view = self.view()?;

        let Some(st) = view.bookmarks.get(name) else {

            return fail(format!("no bookmark {name}"));

        };

        let heads = self.store.get_state(st)?.heads;

        let out =

            self.checkout_carry(&heads, name, &format!("oxy bookmark switch {name} --carry"))?;

        fs::create_dir_all(self.workspace_bookmark_path().parent().unwrap())?;

        write_atomic(&self.workspace_bookmark_path(), name.as_bytes())?;

        self.config.bookmark = name.to_string();

        self.snapshot(&format!("oxy bookmark switch {name} --carry"))?;

        Ok(out)

    }

    /// Check out `heads` taking uncommitted work along: every path the

    /// working copy changes must be the same in the target state as in the

    /// working copy's base, so carrying the files over applies exactly the

    /// same edits there. Otherwise nothing happens and the error names the

    /// paths that differ (`target` names the state in it). Returns the

    /// checkout report and the carried paths.

    pub fn checkout_carry(

        &self,

        heads: &[ChangeHash],

        target: &str,

        command: &str,

    ) -> Result<(CheckoutReport, Vec<String>)> {

        let _wc = self.lock_working_copy()?;

        let snap = self.snapshot(command)?;

        // Every path the work touches: changed ones, and base files it

        // removed or renamed away (a rename reports only its new path).

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

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

            if f.kind != NodeKind::Dir

                && f.kind != NodeKind::Subrepo

                && fs::symlink_metadata(self.root.join(p)).is_err()

            {

                touched.insert(p.clone());

            }

        }

        let target_state = self.load_state(heads)?.materialize();

        let same = |p: &String| {

            let a = snap.base_snapshot.files.get(p);

            let b = target_state.files.get(p);

            match (a, b) {

                (None, None) => true,

                (Some(a), Some(b)) => {

                    a.kind == b.kind && a.mode == b.mode && a.content == b.content

                }

                _ => false,

            }

        };

        let differ: Vec<&String> = touched.iter().filter(|p| !same(p)).collect();

        if !differ.is_empty() {

            let list: Vec<&str> = differ.iter().take(10).map(|p| p.as_str()).collect();

            return fail(format!(

                "{target} has other versions of {} you changed ({}{}); commit first, or drop the changes with --discard",

                if differ.len() == 1 { "a file" } else { "files" },

                list.join(", "),

                if differ.len() > 10 { ", …" } else { "" }

            ));

        }

        // A subrepo whose pin is carried work keeps its own state: checking

        // it out at the target's pin would roll it back (oxygen#38).

        let keep: BTreeSet<String> = touched

            .iter()

            .filter(|p| {

                snap.base_snapshot

                    .files

                    .get(*p)

                    .or_else(|| target_state.files.get(*p))

                    .is_some_and(|f| f.kind == NodeKind::Subrepo)

            })

            .cloned()

            .collect();

        // The work as it is on disk: content and mode, or absent.

        let mut carried: Vec<(String, Carried)> = Vec::new();

        for p in &touched {

            if keep.contains(p) {

                carried.push((p.clone(), Carried::Subrepo));

                continue;

            }

            let full = self.root.join(p);

            let item = match fs::symlink_metadata(&full) {

                Ok(m) if m.file_type().is_symlink() => {