//! 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 `origin`'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"

}

impl Repo {

    fn workspace_bookmark_path(&self) -> PathBuf {

        self.oxy

            .join("workspaces")

            .join(self.workspace.to_hex())

            .join("bookmark")

    }

    /// Every bookmark with its heads and remote-tracking difference.

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

        let view = self.view()?;

        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("origin").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)

    }

    /// 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(h)?.maximal(h),

            None => {

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

                self.load_state(&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)

    }

    /// 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(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 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: every path the working copy changes must be the same

    /// in `name`'s 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. Returns the

    /// checkout report and the carried paths.

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

        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 snap = self.snapshot(&format!("oxy bookmark switch {name} --carry"))?;

        // 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 = self.load_state(&heads)?.materialize();

        let same = |p: &String| {

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

            let b = target.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!(

                "{name} has other versions of {} you changed ({}{}); commit first, or switch with --discard",

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

                list.join(", "),

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

            ));

        }

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

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

        for p in &touched {

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

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

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

                    Carried::Symlink(fs::read_link(&full)?.to_string_lossy().as_bytes().to_vec())

                }

                Ok(m) if m.is_file() => Carried::File(is_executable(&m), fs::read(&full)?),

                Ok(_) => continue,

                Err(_) => Carried::Absent,

            };

            carried.push((p.clone(), item));

        }

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

        for (p, item) in &carried {

            match item {

                Carried::Symlink(target) => self.write_symlink(p, target)?,

                Carried::File(exec, bytes) => self.write_file(p, bytes, *exec)?,

                Carried::Absent => {

                    let _ = fs::remove_file(self.root.join(p));

                }

            }

        }

        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.drop_manifest();

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

        Ok((report, carried.into_iter().map(|(p, _)| p).collect()))

    }

    /// Record `name` as the current bookmark of a new workspace.

    pub(crate) fn set_workspace_bookmark(&self, id: &WorkspaceId, name: &str) -> Result<()> {

        let dir = self.oxy.join("workspaces").join(id.to_hex());

        fs::create_dir_all(&dir)?;

        write_atomic(&dir.join("bookmark"), name.as_bytes())

    }

    /// Union the heads of bookmark `name` into the current bookmark (spec

    /// §10.1). The working copy follows when it was clean on the old heads.

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

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

        let current = self.config.bookmark.clone();

        if name == current {

            return fail(format!("{name} is the current bookmark"));

        }

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

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

        };

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

        let local = self.heads_of(&op.view, &current)?;

        let mut all = local.clone();

        all.extend(other);

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

        heads.sort();

        let mut sorted_local = local.clone();

        sorted_local.sort();

        if heads == sorted_local {

            return Ok(MergeReport {

                heads,

                changed: false,

                checked_out: false,

            });

        }

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

        view.bookmarks.insert(

            current,

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

        );

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

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

        let clean = snap.wc.tree_ops.is_empty() && snap.wc.edits.is_empty();

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

        base.sort();

        let mut checked_out = false;

        if clean && base == sorted_local {

            self.checkout(&heads, false, "oxy merge (checkout)")?;

            checked_out = true;

        }

        Ok(MergeReport {

            heads,

            changed: true,

            checked_out,

        })

    }

}

/// A path's state on disk, taken along by `bookmark switch --carry`.

enum Carried {

    Symlink(Vec<u8>),

    /// Executable bit and content.

    File(bool, Vec<u8>),

    Absent,

}