//! tree usecase: impl TreeOps for GitRepository.

use crate::GitRepository;
use crate::object::types::ObjectType;
use crate::tree::impls::TreeOps;
use crate::tree::types::{
    EntryFollowResult, EntryMode, PathLastUpdated, PathResult, Tree, TreeEntry,
};

fn entry_to_type(mode: gix::objs::tree::EntryMode) -> ObjectType {
    match mode.kind() {
        gix::objs::tree::EntryKind::Tree => ObjectType::Tree,
        gix::objs::tree::EntryKind::Blob
        | gix::objs::tree::EntryKind::BlobExecutable
        | gix::objs::tree::EntryKind::Link => ObjectType::Blob,
        gix::objs::tree::EntryKind::Commit => ObjectType::Commit,
    }
}

fn entry_to_tree_entry(repo: &gix::Repository, e: gix::objs::tree::EntryRef) -> TreeEntry {
    let mode = EntryMode::from(e.mode);
    let size = if mode.is_blob() {
        repo.find_object(e.oid).ok().map(|o| o.data.len() as i64)
    } else {
        None
    };
    TreeEntry {
        id: e.oid.to_owned(),
        name: e.filename.to_string(),
        mode,
        size,
        object_type: entry_to_type(e.mode),
    }
}

impl TreeOps for GitRepository {
    fn tree_read(&self, id: &gix::hash::ObjectId) -> Result<Tree, crate::Error> {
        if let Some(hit) = self.cache_get_oid::<Tree>("tree", id) {
            return Ok(hit);
        }
        let repo = self.repo()?;
        let tree = repo
            .find_tree(*id)
            .map_err(|e| crate::Error::Find(e.to_string()))?;
        let refs = tree
            .decode()
            .map_err(|e| crate::Error::Find(e.to_string()))?;
        let entries = refs
            .entries
            .iter()
            .map(|e| entry_to_tree_entry(&repo, *e))
            .collect();
        let v = Tree { id: *id, entries };
        self.cache_put_oid("tree", id, &v);
        Ok(v)
    }

    fn tree_resolve_path(
        &self,
        tree_id: &gix::hash::ObjectId,
        path: &str,
    ) -> Result<TreeEntry, crate::Error> {
        let tip = self.tip_id()?;
        let key = format!("{tree_id}.{path}");
        if let Some(hit) = self.cache_get_rev::<TreeEntry>("tree", "resolve", &key, tip) {
            return Ok(hit);
        }
        let repo = self.repo()?;
        let mut current = repo
            .find_tree(*tree_id)
            .map_err(|e| crate::Error::Find(e.to_string()))?;
        let mut parts = path.split('/').filter(|s| !s.is_empty());
        let mut last = None;
        while let Some(part) = parts.next() {
            let entry =
                current
                    .find_entry(part.as_bytes())
                    .ok_or_else(|| crate::Error::NotFound {
                        name: part.to_string(),
                    })?;
            let te = entry_to_tree_entry(&repo, entry.inner);
            if parts.clone().next().is_some() {
                if !te.mode.is_dir() {
                    return Err(crate::Error::NotFound {
                        name: path.to_string(),
                    });
                }
                current = repo
                    .find_tree(te.id)
                    .map_err(|e| crate::Error::Find(e.to_string()))?;
            }
            last = Some(te);
        }
        let v = last.ok_or_else(|| crate::Error::NotFound {
            name: path.to_string(),
        })?;
        self.cache_put_rev("tree", "resolve", &key, tip, &v);
        Ok(v)
    }

    fn tree_walk(&self, tree_id: &gix::hash::ObjectId) -> Result<Vec<PathResult>, crate::Error> {
        if let Some(hit) = self.cache_get_oid::<Vec<PathResult>>("tree_walk", tree_id) {
            return Ok(hit);
        }
        let mut out = Vec::new();
        let mut stack = vec![(*tree_id, String::new())];
        let repo = self.repo()?;
        while let Some((id, prefix)) = stack.pop() {
            let tree = repo
                .find_tree(id)
                .map_err(|e| crate::Error::Find(e.to_string()))?;
            let refs = tree
                .decode()
                .map_err(|e| crate::Error::Find(e.to_string()))?;
            for e in refs.entries.iter() {
                let name = e.filename.to_string();
                let path = if prefix.is_empty() {
                    name.clone()
                } else {
                    format!("{prefix}/{name}")
                };
                let te = entry_to_tree_entry(&repo, *e);
                out.push(PathResult {
                    entry: te.clone(),
                    path: path.clone(),
                });
                if te.mode.is_dir() {
                    stack.push((te.id, path));
                }
            }
        }
        self.cache_put_oid("tree_walk", tree_id, &out);
        Ok(out)
    }

    fn tree_follow(&self, entry: &TreeEntry) -> Result<EntryFollowResult, crate::Error> {
        if let Some(hit) = self.cache_get_oid::<EntryFollowResult>("tree_follow", &entry.id) {
            return Ok(hit);
        }
        let repo = self.repo()?;
        let v = if !entry.mode.is_link() {
            EntryFollowResult {
                symlink_content: None,
                target_full_path: None,
                target_entry: Some(entry.clone()),
            }
        } else {
            let blob = repo
                .find_blob(entry.id)
                .map_err(|e| crate::Error::Find(e.to_string()))?;
            let content = String::from_utf8_lossy(&blob.data).to_string();
            EntryFollowResult {
                symlink_content: Some(content),
                target_full_path: None,
                target_entry: None,
            }
        };
        self.cache_put_oid("tree_follow", &entry.id, &v);
        Ok(v)
    }

    fn tree_last_updated(&self, rev: &str) -> Result<Vec<PathLastUpdated>, crate::Error> {
        crate::validate::validate_short_name("revision", rev)?;
        let tip = self.tip_id()?;
        if let Some(hit) =
            self.cache_get_rev::<Vec<PathLastUpdated>>("tree", "last_updated", rev, tip)
        {
            return Ok(hit);
        }
        let repo = self.repo()?;
        let commit_id = repo
            .rev_parse_single(rev.as_bytes())
            .map_err(|e| crate::Error::RevParse(e.to_string()))?
            .detach();
        let commit = repo
            .find_commit(commit_id)
            .map_err(|e| crate::Error::Find(e.to_string()))?;
        let decoded = commit
            .decode()
            .map_err(|e| crate::Error::Find(e.to_string()))?
            .into_owned()
            .map_err(|e| crate::Error::Find(e.to_string()))?;
        let commit_time = decoded.committer.time.seconds;
        let tree_id = decoded.tree;

        // Single pass over history: path -> (last commit time, last commit id)
        // (newest commit wins, since git log is newest-first).
        let repo_path = repo.path();
        let log = crate::gitcli::run(
            repo_path,
            &[
                "log",
                "--format=%H%n%ct",
                "--name-only",
                "--no-renames",
                rev,
            ],
        )?;
        let mut last: std::collections::HashMap<String, (i64, gix::hash::ObjectId)> =
            std::collections::HashMap::new();
        let mut cur_hash: Option<gix::hash::ObjectId> = None;
        let mut cur_time: Option<i64> = None;
        let mut stage = 0u8; // 0=hash, 1=time, 2=files
        for line in log.lines() {
            let line = line.trim();
            if line.is_empty() {
                if stage == 2 {
                    stage = 0;
                    cur_hash = None;
                    cur_time = None;
                }
                continue;
            }
            match stage {
                0 => {
                    if line.len() == 40
                        && let Ok(id) = gix::hash::ObjectId::from_hex(line.as_bytes())
                    {
                        cur_hash = Some(id);
                        stage = 1;
                    }
                }
                1 => {
                    if let Ok(ts) = line.parse::<i64>() {
                        cur_time = Some(ts);
                        stage = 2;
                    }
                }
                _ => {
                    if let (Some(ts), Some(id)) = (cur_time, cur_hash) {
                        last.entry(line.to_string()).or_insert((ts, id));
                    }
                }
            }
        }

        let mut out = Vec::new();
        walk_last_updated(&repo, tree_id, "", &last, commit_time, commit_id, &mut out)?;
        let tip = self.tip_id()?;
        self.cache_put_rev("tree", "last_updated", rev, tip, &out);
        Ok(out)
    }
}

// Recursively walk a tree, emitting each path's last-update info.
// For directories, the last-update time/id is the max over its descendants.
fn walk_last_updated(
    repo: &gix::Repository,
    tree_id: gix::ObjectId,
    prefix: &str,
    last: &std::collections::HashMap<String, (i64, gix::hash::ObjectId)>,
    commit_time: i64,
    commit_id: gix::hash::ObjectId,
    out: &mut Vec<PathLastUpdated>,
) -> Result<(i64, gix::hash::ObjectId), crate::Error> {
    let tree = repo
        .find_tree(tree_id)
        .map_err(|e| crate::Error::Find(e.to_string()))?;
    let refs = tree
        .decode()
        .map_err(|e| crate::Error::Find(e.to_string()))?;
    let mut dir_max_time = commit_time;
    let mut dir_max_id = commit_id;
    for e in refs.entries.iter() {
        let name = e.filename.to_string();
        let path = if prefix.is_empty() {
            name.clone()
        } else {
            format!("{prefix}/{name}")
        };
        let mode = EntryMode::from(e.mode);
        let (this_time, this_id) = last.get(&path).copied().unwrap_or((commit_time, commit_id));
        if mode.is_dir() {
            let (child_max_time, child_max_id) = walk_last_updated(
                repo,
                e.oid.to_owned(),
                &path,
                last,
                commit_time,
                commit_id,
                out,
            )?;
            let (t, id) = if this_time >= child_max_time {
                (this_time, this_id)
            } else {
                (child_max_time, child_max_id)
            };
            out.push(PathLastUpdated {
                path,
                object_type: ObjectType::Tree,
                last_updated: t,
                commit_id: id,
            });
            if t > dir_max_time {
                dir_max_time = t;
                dir_max_id = id;
            }
        } else {
            out.push(PathLastUpdated {
                path,
                object_type: entry_to_type(e.mode),
                last_updated: this_time,
                commit_id: this_id,
            });
            if this_time > dir_max_time {
                dir_max_time = this_time;
                dir_max_id = this_id;
            }
        }
    }
    Ok((dir_max_time, dir_max_id))
}
#[cfg(test)]
mod tests {
    use super::*;
    use crate::GitRepository;
    use crate::object::cache::ObjectCache;
    use cache::CacheBuilder;
    use storage::config::StorageSettings;
    use storage::local::LocalStorage;

    fn block_on<F: std::future::Future>(f: F) -> F::Output {
        tokio::runtime::Builder::new_current_thread()
            .enable_all()
            .build()
            .unwrap()
            .block_on(f)
    }

    fn make_repo(dir: &std::path::Path, name: &str) -> GitRepository {
        let cache_cfg = cache::config::cache::AppCacheSettings::default();
        let cache = block_on(CacheBuilder::from_config(cache_cfg).build())
            .expect("cache build")
            .expect("cache enabled");
        let cache = std::sync::Arc::new(cache);
        let oc = ObjectCache {
            prefix: "test".to_string(),
            cache,
            expire_ttl: 300,
        };
        let mut settings = StorageSettings::default();
        settings.set_local(
            storage::config::LocalStorageSettings::builder()
                .root_dir(dir.join("storage").to_path_buf())
                .build(),
        );
        let storage: std::sync::Arc<Box<dyn storage::StorageRepository>> = std::sync::Arc::new(
            Box::new(LocalStorage::from_config(&settings).expect("storage")),
        );
        GitRepository::new(dir.join(name), oc, storage)
    }

    fn run_stdin(repo_path: &std::path::Path, args: &[&str], input: &[u8]) -> String {
        let out = duct::cmd("git", args)
            .env("GIT_DIR", repo_path)
            .env("GIT_TERMINAL_PROMPT", "0")
            .stdin_bytes(input)
            .stdout_capture()
            .stderr_capture()
            .run()
            .unwrap();
        String::from_utf8_lossy(&out.stdout).trim().to_string()
    }

    #[test]
    fn tree_last_updated_reports_blob_and_dir_times() {
        let tmp = std::env::temp_dir().join(format!("git-lastupd-test-{}", std::process::id()));
        let _ = std::fs::remove_dir_all(&tmp);
        let repo = make_repo(&tmp, "main");
        crate::gitcli::run(&repo.path, &["init", "-q", "--bare", "-b", "main"]).unwrap();
        crate::gitcli::run(&repo.path, &["config", "user.email", "t@t"]).unwrap();
        crate::gitcli::run(&repo.path, &["config", "user.name", "t"]).unwrap();

        let blob_a = run_stdin(&repo.path, &["hash-object", "-w", "--stdin"], b"a\n");
        let blob_b = run_stdin(&repo.path, &["hash-object", "-w", "--stdin"], b"b\n");
        let tree_d = run_stdin(
            &repo.path,
            &["mktree", "-z"],
            &format!("100644 blob {blob_b}\td.txt\0").into_bytes(),
        );
        let tree_root = run_stdin(
            &repo.path,
            &["mktree", "-z"],
            &format!("100644 blob {blob_a}\ta.txt\040000 tree {tree_d}\td\0").into_bytes(),
        );
        let c1 = run_stdin(&repo.path, &["commit-tree", &tree_root, "-m", "init"], b"");
        crate::gitcli::run(&repo.path, &["update-ref", "refs/heads/main", &c1]).unwrap();

        let res = TreeOps::tree_last_updated(&repo, "main").unwrap();
        let by_path: std::collections::HashMap<_, _> =
            res.iter().map(|p| (p.path.clone(), p)).collect();
        assert!(by_path.contains_key("a.txt"));
        assert!(by_path.contains_key("d/d.txt"));
        assert!(by_path.contains_key("d"));
        assert!(by_path["a.txt"].last_updated > 0);
        assert_eq!(by_path["a.txt"].commit_id.to_string(), c1);
        assert_eq!(by_path["d/d.txt"].commit_id.to_string(), c1);
        assert_eq!(by_path["d"].commit_id.to_string(), c1);
        assert!(by_path["d"].last_updated >= by_path["d/d.txt"].last_updated);
        let _ = std::fs::remove_dir_all(&tmp);
    }
}