//! The nodes each change touches, kept beside the store (oxygen#91).
//!
//! Finding the changes that touched a file (`oxy log --path`, the
//! `touches()` revset) otherwise reads and decodes every change of the
//! history, its lines included. A change is immutable, so its entry never
//! goes stale: one missing is read from the store once and added. Like
//! Git's changed-path filters it is derived data, and deleting
//! `.oxy/index/touched` loses nothing but time.

use super::*;
use crate::fasthash::FastMap;
use crate::ids::NodeId;

/// The cache, loaded; [`Touched::save`] writes it back when it grew.
pub(crate) struct Touched {
    nodes: FastMap<ChangeHash, Box<[NodeId]>>,
    /// Working-copy changes, which a snapshot replaces: kept for this
    /// command only, so the cache does not fill with dead entries.
    transient: FastMap<ChangeHash, Box<[NodeId]>>,
    added: usize,
    path: PathBuf,
}

impl Touched {
    /// The nodes `h` touches, from the cache or else from the store; `None`
    /// when the change is not stored (beyond a shallow boundary).
    pub(crate) fn of(&mut self, repo: &Repo, h: &ChangeHash) -> Option<&[NodeId]> {
        if !self.nodes.contains_key(h) && !self.transient.contains_key(h) {
            // The skeleton names every node; no text is read.
            let (c, _) = repo.store.get_change_lazy(h).ok()?;
            self.keep(*h, &c);
        }
        self.nodes
            .get(h)
            .or_else(|| self.transient.get(h))
            .map(|n| &n[..])
    }

    fn keep(&mut self, h: ChangeHash, c: &Change) {
        if c.kind == ChangeKind::WorkingCopy {
            self.transient.insert(h, nodes_of(c));
        } else {
            self.nodes.insert(h, nodes_of(c));
            self.added += 1;
        }
    }

    /// Read every one of `hashes` the cache lacks.
    pub(crate) fn fill(&mut self, repo: &Repo, hashes: &[ChangeHash]) {
        use rayon::prelude::*;
        let missing: Vec<ChangeHash> = hashes
            .iter()
            .filter(|h| !self.nodes.contains_key(*h) && !self.transient.contains_key(*h))
            .copied()
            .collect();
        // Read a batch at a time, then decode skeletons (no text) on every
        // core. A change the store lacks is left out, as `of` leaves it.
        for batch in missing.chunks(8192) {
            let read: Vec<(ChangeHash, Change)> = repo
                .store
                .get_many(batch)
                .into_par_iter()
                .zip(batch.par_iter())
                .filter_map(|(got, h)| match got {
                    Ok((ObjectType::Change, bytes)) => {
                        Some((*h, Change::decode_skeleton(&bytes, *h).ok()?.0))
                    }
                    _ => None,
                })
                .collect();
            for (h, c) in &read {
                self.keep(*h, c);
            }
        }
    }

    /// Whether `h` touches any of `nodes` (false when it is not stored).
    pub(crate) fn touches(&mut self, repo: &Repo, h: &ChangeHash, nodes: &HashSet<NodeId>) -> bool {
        self.of(repo, h)
            .is_some_and(|n| n.iter().any(|n| nodes.contains(n)))
    }

    /// Write the cache back if it grew; quietly nothing when it cannot be.
    pub(crate) fn save(self) {
        if self.added == 0 {
            return;
        }
        let _t = crate::timing::phase("write: touched nodes");
        let mut w = crate::flat::Writer::default();
        w.count(self.nodes.len());
        for (h, nodes) in &self.nodes {
            w.object(h);
            w.count(nodes.len());
            for n in nodes.iter() {
                w.fixed(&n.0);
            }
        }
        // Checked whole on reading: a damaged entry would hide a change.
        let sum = *blake3::hash(&w.0).as_bytes();
        w.fixed(&sum);
        let _ = fs::create_dir_all(self.path.parent().unwrap_or(&self.path));
        let _ = write_cache(&self.path, &w.0);
    }
}

/// The nodes a change's tree operations and edits name, each once.
fn nodes_of(c: &Change) -> Box<[NodeId]> {
    let mut nodes: Vec<NodeId> = c
        .tree_ops
        .iter()
        .map(|o| o.node())
        .chain(c.edits.iter().map(|e| e.node()))
        .collect();
    nodes.sort();
    nodes.dedup();
    nodes.into_boxed_slice()
}

impl Repo {
    /// The touched-nodes cache: empty when there is none yet or it does
    /// not read back whole.
    pub(crate) fn touched(&self) -> Touched {
        let _t = crate::timing::phase("load: touched nodes");
        let path = self.oxy.join("index").join("touched");
        let nodes = fs::read(&path)
            .ok()
            .and_then(|b| read_touched(&b))
            .unwrap_or_default();
        Touched {
            nodes,
            transient: FastMap::default(),
            added: 0,
            path,
        }
    }
}

fn read_touched(bytes: &[u8]) -> Option<FastMap<ChangeHash, Box<[NodeId]>>> {
    let (body, sum) = bytes.split_at_checked(bytes.len().checked_sub(32)?)?;
    if blake3::hash(body).as_bytes() != sum {
        return None;
    }
    let mut r = crate::flat::Reader::new(body);
    let n = r.count().ok()?;
    let mut out = FastMap::default();
    out.reserve(n);
    for _ in 0..n {
        let h = r.object().ok()?;
        let k = r.count().ok()?;
        let mut nodes = Vec::with_capacity(k);
        for _ in 0..k {
            nodes.push(NodeId(r.fixed::<16>().ok()?));
        }
        out.insert(h, nodes.into_boxed_slice());
    }
    r.at_end().then_some(out)
}

/// The changes a cache file holds, for tests.
#[cfg(test)]
pub(crate) fn read_touched_for_test(bytes: &[u8]) -> Option<HashSet<ChangeHash>> {
    read_touched(bytes).map(|m| m.into_keys().collect())
}