//! A job's workspace: the files of the state being built, written to a

//! scratch directory and packed into an ext4 image for the microVM

//! (docs/m0.md §2). Returns each file's content hash for the scope hash.

use anyhow::{bail, Context, Result};

use flow_core::Hash;

use oxy_core::hash::ChangeHash;

use oxy_core::objects::NodeKind;

use oxy_core::repo::Repo;

use oxy_core::state::FileContent;

use std::path::Path;

pub type Files = Vec<(String, Hash)>;

/// Write the state `heads` of `repo` under `dir`.

pub fn export_state(repo: &Repo, heads: &[ChangeHash], dir: &Path) -> Result<Files> {

    let snapshot = repo.load_state(heads).context("load the state")?.materialize();

    let mut files = Vec::new();

    for (path, f) in &snapshot.files {

        if path.split('/').any(|p| p.is_empty() || p == "." || p == ".." || p == ".oxy") {

            continue;

        }

        let target = dir.join(path);

        match (&f.kind, &f.content) {

            (NodeKind::Dir, _) | (_, FileContent::Dir) => std::fs::create_dir_all(&target)?,

            (NodeKind::Subrepo, _) => {}

            (kind, content) => {

                let bytes = match content {

                    FileContent::Text { bytes, .. } => bytes.clone(),

                    FileContent::Opaque { blobs } => match blobs.first() {

                        Some(b) => repo.read_blob(b)?,

                        None => Vec::new(),

                    },

                    FileContent::Dir => unreachable!(),

                };

                if let Some(parent) = target.parent() {

                    std::fs::create_dir_all(parent)?;

                }

                if *kind == NodeKind::Symlink {

                    let to = String::from_utf8_lossy(&bytes).into_owned();

                    std::os::unix::fs::symlink(&to, &target).with_context(|| format!("symlink {path}"))?;

                } else {

                    std::fs::write(&target, &bytes).with_context(|| format!("write {path}"))?;

                    if f.mode.exec {

                        use std::os::unix::fs::PermissionsExt;

                        std::fs::set_permissions(&target, std::fs::Permissions::from_mode(0o755))?;

                    }

                }

                files.push((path.clone(), *blake3::hash(&bytes).as_bytes()));

            }

        }

    }

    Ok(files)

}

/// Copy a working directory (without `.oxy` and what `.oxyignore` and

/// `.gitignore` exclude) under `dir`, for `flow run`.

pub fn copy_tree(src: &Path, dir: &Path) -> Result<Files> {

    let mut files = Vec::new();

    let walk = ignore::WalkBuilder::new(src)

        .hidden(false)

        .git_ignore(true)

        .require_git(false)

        .add_custom_ignore_filename(".oxyignore")

        .filter_entry(|e| e.file_name() != ".oxy" && e.file_name() != ".git")

        .build();

    for entry in walk {

        let entry = entry?;

        let rel = entry.path().strip_prefix(src)?;

        if rel.as_os_str().is_empty() {

            continue;

        }

        let rel_s = rel.to_string_lossy().replace('\\', "/");

        let target = dir.join(rel);

        let ft = entry.file_type().context("file type")?;

        if ft.is_dir() {

            std::fs::create_dir_all(&target)?;

        } else if ft.is_symlink() {

            let to = std::fs::read_link(entry.path())?;

            std::os::unix::fs::symlink(&to, &target)?;

            files.push((rel_s, *blake3::hash(to.to_string_lossy().as_bytes()).as_bytes()));

        } else if ft.is_file() {

            std::fs::copy(entry.path(), &target)?;

            files.push((rel_s, *blake3::hash(&std::fs::read(entry.path())?).as_bytes()));

        }

    }

    Ok(files)

}

/// Pack `dir` into an ext4 image whose root belongs to this user, so the

/// job (which runs as the owner of `/src`) can write to it.

pub fn image(dir: &Path, out: &Path) -> Result<()> {

    let used: u64 = ignore::WalkBuilder::new(dir)

        .hidden(false)

        .ignore(false)

        .git_ignore(false)

        .build()

        .flatten()

        .filter_map(|e| e.metadata().ok())

        .map(|m| m.len().max(4096))

        .sum();

    let mib = used * 12 / 10 / (1 << 20) + 512;

    let (uid, gid) = unsafe { (libc::getuid(), libc::getgid()) };

    let status = std::process::Command::new("mkfs.ext4")

        .args(["-q", "-F", "-L", "workspace", "-E"])

        .arg(format!("root_owner={uid}:{gid}"))

        .arg("-d")

        .arg(dir)

        .arg(out)

        .arg(format!("{mib}M"))

        .status()

        .context("run mkfs.ext4 (e2fsprogs 1.43 or later)")?;

    if !status.success() {

        bail!("mkfs.ext4 failed for the workspace image");

    }

    Ok(())

}

/// Give the files of `dir` whose content a cached disk was built from

/// the mtime they had then (oxygenflow#52), and describe this checkout's

/// sources for the disk to keep: unchanged files are fresh to a build

/// tool that judges by time, changed ones newer than anything it built.

/// Whole seconds, as the workspace image keeps them. Returns the sources

/// and how many files got their time back.

pub fn restore_times(dir: &Path, files: &Files, before: Option<&crate::cache::Sources>) -> (crate::cache::Sources, usize) {

    let mut out = crate::cache::Sources::new();

    let mut restored = 0;

    for (path, hash) in files {

        let p = dir.join(path);

        let Ok(md) = std::fs::symlink_metadata(&p) else { continue };

        if !md.is_file() {

            continue;

        }

        let hex = hex::encode(hash);

        let kept = before.and_then(|b| b.get(path)).filter(|(h, _)| *h == hex).map(|(_, t)| *t);

        let t = match kept {

            Some(t) => {

                let at = std::time::UNIX_EPOCH + std::time::Duration::from_secs(t.max(0) as u64);

                if std::fs::File::options().write(true).open(&p).and_then(|f| f.set_modified(at)).is_err() {

                    continue;

                }

                restored += 1;

                t

            }

            None => md.modified().ok().and_then(|m| m.duration_since(std::time::UNIX_EPOCH).ok()).map(|d| d.as_secs() as i64).unwrap_or(0),

        };

        out.insert(path.clone(), (hex, t));

    }

    // Directories too, after their files (#52): a build script's

    // `rerun-if-changed` on a directory looks at its time as well. A

    // directory whose listing is unchanged gets its old time back; one that

    // gained or lost an entry keeps its checkout's, so the change shows.

    restore_dir_times(dir, Path::new(""), before, &mut out, &mut restored);

    (out, restored)

}

/// The key a directory's entry has in the sources: its path and a slash.

fn dir_key(rel: &Path) -> String {

    format!("{}/", rel.display())

}

fn restore_dir_times(

    root: &Path,

    rel: &Path,

    before: Option<&crate::cache::Sources>,

    out: &mut crate::cache::Sources,

    restored: &mut usize,

) {

    let here = root.join(rel);

    let Ok(entries) = std::fs::read_dir(&here) else { return };

    let mut names: Vec<(String, bool)> = Vec::new();

    for e in entries.flatten() {

        let is_dir = e.file_type().is_ok_and(|t| t.is_dir());

        names.push((e.file_name().to_string_lossy().into_owned(), is_dir));

    }

    names.sort();

    for (name, is_dir) in &names {

        if *is_dir {

            restore_dir_times(root, &rel.join(name), before, out, restored);

        }

    }

    let mut h = blake3::Hasher::new();

    for (name, is_dir) in &names {

        h.update(name.as_bytes());

        h.update(if *is_dir { b"/\n".as_slice() } else { b"\n".as_slice() });

    }

    let hex = h.finalize().to_hex().to_string();

    let key = dir_key(rel);

    let kept = before.and_then(|b| b.get(&key)).filter(|(h, _)| *h == hex).map(|(_, t)| *t);

    let t = match kept {

        Some(t) => {

            let at = std::time::UNIX_EPOCH + std::time::Duration::from_secs(t.max(0) as u64);

            if std::fs::File::open(&here).and_then(|f| f.set_modified(at)).is_err() {

                return;

            }

            *restored += 1;

            t

        }

        None => std::fs::metadata(&here)

            .ok()

            .and_then(|m| m.modified().ok())

            .and_then(|m| m.duration_since(std::time::UNIX_EPOCH).ok())

            .map(|d| d.as_secs() as i64)

            .unwrap_or(0),

    };

    out.insert(key, (hex, t));

}

/// An empty ext4 filesystem of `mib` MiB at `out`, owned by this user like

/// the workspace. mkfs.ext4 creates the file sparse, so only what the job

/// writes takes space on the runner.

pub fn empty_ext4(out: &Path, mib: u32, label: &str) -> Result<()> {

    let (uid, gid) = unsafe { (libc::getuid(), libc::getgid()) };

    let status = std::process::Command::new("mkfs.ext4")

        .args(["-q", "-F", "-L", label, "-E"])

        .arg(format!("root_owner={uid}:{gid}"))

        .arg(out)

        .arg(format!("{mib}M"))

        .status()

        .context("run mkfs.ext4 (e2fsprogs 1.43 or later)")?;

    if !status.success() {

        bail!("mkfs.ext4 failed for a scratch disk");

    }

    Ok(())

}

/// Remove `dir` and everything in it, even where a job took away its own

/// write or search permission on a directory; links are never followed.

pub fn remove_tree(dir: &Path) -> std::io::Result<()> {

    match std::fs::remove_dir_all(dir) {

        Ok(()) => Ok(()),

        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(()),

        Err(_) => {

            open_up(dir);

            std::fs::remove_dir_all(dir)

        }

    }

}

fn open_up(dir: &Path) {

    use std::os::unix::fs::PermissionsExt;

    let Ok(meta) = std::fs::symlink_metadata(dir) else { return };

    if !meta.is_dir() {

        return;

    }

    let _ = std::fs::set_permissions(dir, std::fs::Permissions::from_mode(0o700));

    if let Ok(entries) = std::fs::read_dir(dir) {

        for e in entries.flatten() {

            open_up(&e.path());

        }

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    use std::time::UNIX_EPOCH;

    fn secs(p: &Path) -> i64 {

        std::fs::metadata(p).unwrap().modified().unwrap().duration_since(UNIX_EPOCH).unwrap().as_secs() as i64

    }

    /// oxygenflow#52: an unchanged file gets the time it had when the cached

    /// disk was built; a changed or new one keeps its checkout's, newer.

    #[test]

    fn unchanged_sources_get_their_cached_times_back() {

        let dir = tempfile::tempdir().unwrap();

        for (name, text) in [("same.rs", "a"), ("changed.rs", "b2"), ("new.rs", "c")] {

            std::fs::write(dir.path().join(name), text).unwrap();

        }

        std::os::unix::fs::symlink("same.rs", dir.path().join("link.rs")).unwrap();

        let h = |t: &str| *blake3::hash(t.as_bytes()).as_bytes();

        let files: Files =

            vec![("same.rs".into(), h("a")), ("changed.rs".into(), h("b2")), ("new.rs".into(), h("c")), ("link.rs".into(), h("same.rs"))];

        let now = secs(&dir.path().join("same.rs"));

        let before: crate::cache::Sources =

            [("same.rs".to_string(), (hex::encode(h("a")), 1_000_000)), ("changed.rs".to_string(), (hex::encode(h("b1")), 1_000_000))]

                .into();

        let (sources, restored) = restore_times(dir.path(), &files, Some(&before));

        assert_eq!(restored, 1);

        assert_eq!(secs(&dir.path().join("same.rs")), 1_000_000, "unchanged: fresh to cargo");

        assert!(secs(&dir.path().join("changed.rs")) >= now, "changed: newer than the cached build");

        assert_eq!(sources["same.rs"], (hex::encode(h("a")), 1_000_000));

        assert_eq!(sources["changed.rs"].0, hex::encode(h("b2")), "kept with its new content");

        assert!(sources.contains_key("new.rs") && !sources.contains_key("link.rs"), "files only");

        // Without a cached build nothing moves, and the sources are listed:

        // three files and the directory holding them.

        let (again, restored) = restore_times(dir.path(), &files, None);

        assert_eq!((restored, again.len()), (0, 4));

        assert!(again.contains_key("/"));

        // A directory whose listing is unchanged gets its time back; one

        // that gained an entry keeps its new time, so a build script's

        // `rerun-if-changed` on it sees the change.

        std::fs::create_dir(dir.path().join("migrations")).unwrap();

        std::fs::write(dir.path().join("migrations/0001.sql"), "x").unwrap();

        let mut files = files;

        files.push(("migrations/0001.sql".into(), h("x")));

        let (mut kept, _) = restore_times(dir.path(), &files, None);

        kept.get_mut("migrations/").unwrap().1 = 2_000_000;

        kept.get_mut("migrations/0001.sql").unwrap().1 = 2_000_000;

        let (_, restored) = restore_times(dir.path(), &files, Some(&kept));

        assert_eq!(secs(&dir.path().join("migrations")), 2_000_000, "unchanged listing: its old time");

        assert!(restored >= 2);

        std::fs::write(dir.path().join("migrations/0002.sql"), "y").unwrap();

        files.push(("migrations/0002.sql".into(), h("y")));

        let (now_sources, _) = restore_times(dir.path(), &files, Some(&kept));

        assert!(secs(&dir.path().join("migrations")) > 2_000_000, "a new entry: it looks changed");

        assert_ne!(now_sources["migrations/"].0, kept["migrations/"].0);

    }

}