use std::path::Path;

use crate::GitBaby;
use crate::commit::helper;
use crate::commit::types::{
    CommitInfo, CommitShortStat, CommitStats, ListCommitsOptions, TreeEntry,
};
use crate::error::BabyError;

impl GitBaby {
    pub async fn get_commit(&self, revision: &str) -> Result<CommitInfo, BabyError> {
        helper::validate_revision(revision)?;
        let id = self
            .rev_parse(revision)
            .await
            .map_err(helper::facade_error)?;
        let pool = crate::cache::try_global_cache();
        let key = crate::cache::object_key(crate::cache::NS_COMMIT, &id);
        if let Some(p) = &pool
            && let Ok(Some(v)) = p.store().get(&key).await
            && let Ok(info) = serde_json::from_slice(&v)
        {
            return Ok(info);
        }
        let mut cmd = self
            .spawn_commit_cmd(revision, |dir, env| {
                helper::build_get_commit_cmd(dir, env, revision)
            })
            .await?;
        let ctx = helper::StderrCtx {
            revision,
            path: None,
        };
        let output = cmd
            .run()
            .await
            .map_err(|e| helper::classify_cmd_error(e, &ctx))?;
        if !output.status.success() {
            return Err(helper::classify_stderr(
                &String::from_utf8_lossy(&output.stderr),
                &ctx,
            ));
        }
        let info = helper::parse_commit_porcelain(id, &output.stdout)?;
        if let Some(p) = &pool
            && let Ok(v) = serde_json::to_vec(&info)
        {
            p.store().insert(key, v);
        }
        Ok(info)
    }

    pub async fn rev_parse(&self, revision: &str) -> Result<gix::ObjectId, BabyError> {
        helper::validate_revision(revision)?;
        let pool = crate::cache::try_global_cache();
        let key = if pool.is_some() {
            let dir = self
                .facade
                .git_repo_dir()
                .await
                .map_err(helper::facade_error)?;
            let dir = std::fs::canonicalize(&dir)
                .map_err(|source| BabyError::Io { path: dir, source })?;
            Some(crate::cache::rev_key(&dir, revision))
        } else {
            None
        };
        if let (Some(p), Some(key)) = (&pool, &key)
            && let Ok(Some(v)) = p.store().get(key).await
            && let Ok(hex) = String::from_utf8(v)
            && let Ok(oid) = gix::ObjectId::from_hex(hex.trim().as_bytes())
        {
            return Ok(oid);
        }
        let mut cmd = self
            .spawn_commit_cmd(revision, |dir, env| {
                helper::build_rev_parse_cmd(dir, env, revision)
            })
            .await?;
        let ctx = helper::StderrCtx {
            revision,
            path: None,
        };
        let output = cmd
            .run()
            .await
            .map_err(|e| helper::classify_cmd_error(e, &ctx))?;
        if !output.status.success() {
            return Err(helper::classify_stderr(
                &String::from_utf8_lossy(&output.stderr),
                &ctx,
            ));
        }
        let text = String::from_utf8_lossy(&output.stdout);
        let hex = text.trim();
        let oid = gix::ObjectId::from_hex(hex.as_bytes()).map_err(|source| {
            BabyError::Custom(format!(
                "rev-parse returned invalid oid `{}`: {}",
                hex, source
            ))
        })?;
        if let (Some(p), Some(key)) = (&pool, &key) {
            p.store().insert(key.clone(), hex.as_bytes().to_vec());
        }
        Ok(oid)
    }

    pub async fn is_ancestor(&self, ancestor: &str, descendant: &str) -> Result<bool, BabyError> {
        helper::validate_revision(ancestor)?;
        helper::validate_revision(descendant)?;
        let mut cmd = self
            .spawn_commit_cmd(descendant, |dir, env| {
                helper::build_is_ancestor_cmd(dir, env, ancestor, descendant)
            })
            .await?;
        let ctx = helper::StderrCtx {
            revision: descendant,
            path: None,
        };
        let output = match cmd.run().await {
            Ok(o) => o,
            Err(CmdError::NonZeroExit { stderr, .. }) => {
                if stderr.trim().is_empty() {
                    return Ok(false);
                }
                return Err(helper::classify_stderr(&stderr, &ctx));
            }
            Err(e) => return Err(helper::classify_cmd_error(e, &ctx)),
        };
        if output.status.success() {
            Ok(true)
        } else {
            Ok(false)
        }
    }

    pub async fn list_commits(
        &self,
        opts: ListCommitsOptions,
    ) -> Result<Vec<CommitInfo>, BabyError> {
        helper::validate_list_commits_options(&opts)?;
        let rev = opts.revision.clone();
        let mut cmd = self
            .spawn_commit_cmd(&rev, |dir, env| {
                helper::build_list_commits_cmd(dir, env, &opts)
            })
            .await?;
        let ctx = helper::StderrCtx {
            revision: &rev,
            path: opts.path.as_deref(),
        };
        let output = cmd
            .run()
            .await
            .map_err(|e| helper::classify_cmd_error(e, &ctx))?;
        if !output.status.success() {
            return Err(helper::classify_stderr(
                &String::from_utf8_lossy(&output.stderr),
                &ctx,
            ));
        }
        helper::parse_log_porcelain(&output.stdout)
    }

    pub async fn count_commits(&self, opts: ListCommitsOptions) -> Result<u64, BabyError> {
        helper::validate_list_commits_options(&opts)?;
        let rev = opts.revision.clone();
        let mut cmd = self
            .spawn_commit_cmd(&rev, |dir, env| {
                helper::build_count_commits_cmd(dir, env, &opts)
            })
            .await?;
        let ctx = helper::StderrCtx {
            revision: &rev,
            path: opts.path.as_deref(),
        };
        let output = cmd
            .run()
            .await
            .map_err(|e| helper::classify_cmd_error(e, &ctx))?;
        if !output.status.success() {
            return Err(helper::classify_stderr(
                &String::from_utf8_lossy(&output.stderr),
                &ctx,
            ));
        }
        let s = String::from_utf8_lossy(&output.stdout);
        s.trim().parse::<u64>().map_err(|_| BabyError::CommitParse {
            line_number: 0,
            message: format!("rev-list --count returned `{}`", s.trim()),
        })
    }

    pub async fn commit_stats(
        &self,
        revision: &str,
        path: Option<&Path>,
    ) -> Result<CommitStats, BabyError> {
        helper::validate_revision(revision)?;
        if let Some(p) = path {
            helper::validate_path_local_no_escape(p)?;
        }
        let mut cmd = self
            .spawn_commit_cmd(revision, |dir, env| {
                helper::build_commit_stats_cmd(dir, env, revision, path)
            })
            .await?;
        let ctx = helper::StderrCtx { revision, path };
        let output = cmd
            .run()
            .await
            .map_err(|e| helper::classify_cmd_error(e, &ctx))?;
        if !output.status.success() {
            return Err(helper::classify_stderr(
                &String::from_utf8_lossy(&output.stderr),
                &ctx,
            ));
        }
        helper::parse_shortstat(&output.stdout)
    }

    pub async fn commit_short_stats(
        &self,
        revision: &str,
    ) -> Result<Vec<CommitShortStat>, BabyError> {
        helper::validate_revision(revision)?;
        let mut cmd = self
            .spawn_commit_cmd(revision, |dir, env| {
                helper::build_commit_short_stats_cmd(dir, env, revision)
            })
            .await?;
        let ctx = helper::StderrCtx {
            revision,
            path: None,
        };
        let output = cmd
            .run()
            .await
            .map_err(|e| helper::classify_cmd_error(e, &ctx))?;
        if !output.status.success() {
            return Err(helper::classify_stderr(
                &String::from_utf8_lossy(&output.stderr),
                &ctx,
            ));
        }
        helper::parse_commit_short_stats(&output.stdout)
    }

    pub async fn get_tree_entries(
        &self,
        revision: &str,
        path: &Path,
    ) -> Result<Vec<TreeEntry>, BabyError> {
        helper::validate_revision(revision)?;
        helper::validate_path_local_no_escape(path)?;
        let pool = crate::cache::try_global_cache();
        let key = if pool.is_some() {
            match self.rev_parse(revision).await.map_err(helper::facade_error) {
                Ok(oid) => {
                    let mut k =
                        Vec::with_capacity(oid.as_bytes().len() + 1 + path.as_os_str().len());
                    k.extend_from_slice(oid.as_bytes());
                    k.push(0);
                    k.extend_from_slice(path.to_string_lossy().as_bytes());
                    Some(crate::cache::encode(crate::cache::NS_TREE_ENTRIES, &k))
                }
                Err(_) => None,
            }
        } else {
            None
        };
        if let (Some(p), Some(key)) = (&pool, &key)
            && let Ok(Some(v)) = p.store().get(key).await
            && let Ok(entries) = serde_json::from_slice::<Vec<TreeEntry>>(&v)
        {
            return Ok(entries);
        }
        let mut cmd = self
            .spawn_commit_cmd(revision, |dir, env| {
                helper::build_tree_entries_cmd(dir, env, revision, path)
            })
            .await?;
        let ctx = helper::StderrCtx {
            revision,
            path: Some(path),
        };
        let output = cmd
            .run()
            .await
            .map_err(|e| helper::classify_cmd_error(e, &ctx))?;
        if !output.status.success() {
            return Err(helper::classify_stderr(
                &String::from_utf8_lossy(&output.stderr),
                &ctx,
            ));
        }
        let entries = helper::parse_tree_entries(&output.stdout)?;
        if let (Some(p), Some(key)) = (&pool, &key)
            && let Ok(v) = serde_json::to_vec(&entries)
        {
            p.store().insert(key.clone(), v);
        }
        Ok(entries)
    }

    pub async fn tree_entry_at(
        &self,
        revision: &str,
        path: &Path,
    ) -> Result<Option<TreeEntry>, BabyError> {
        helper::validate_revision(revision)?;
        helper::validate_path_local_no_escape(path)?;
        let raw = path.to_string_lossy();
        let clean = raw.trim().trim_start_matches("./");
        if clean.is_empty() || clean == "." {
            return Ok(None);
        }
        let (parent, base) = match clean.rsplit_once('/') {
            Some((p, b)) => (p, b),
            None => ("", clean),
        };
        if base.is_empty() {
            return Ok(None);
        }
        let treeish = if parent.is_empty() {
            format!("{}:", revision)
        } else {
            format!("{}:{}", revision, parent)
        };
        let mut cmd = self
            .spawn_commit_cmd(revision, |dir, env| {
                let args: Vec<String> = ["-c", "core.quotepath=off", "ls-tree", treeish.as_str()]
                    .into_iter()
                    .map(String::from)
                    .collect();
                crate::share::git_cmd(helper::CALLER, dir, env, None, args)
            })
            .await?;
        let ctx = helper::StderrCtx {
            revision,
            path: Some(path),
        };
        let output = cmd
            .run()
            .await
            .map_err(|e| helper::classify_cmd_error(e, &ctx))?;
        if !output.status.success() {
            return Err(helper::classify_stderr(
                &String::from_utf8_lossy(&output.stderr),
                &ctx,
            ));
        }
        let entries = helper::parse_tree_entries(&output.stdout)?;
        Ok(entries.into_iter().find(|e| e.name == base))
    }

    pub async fn last_commit_for_path(
        &self,
        revision: &str,
        path: &Path,
    ) -> Result<CommitInfo, BabyError> {
        helper::validate_revision(revision)?;
        helper::validate_path_local_no_escape(path)?;
        let mut cmd = self
            .spawn_commit_cmd(revision, |dir, env| {
                helper::build_last_commit_for_path_cmd(dir, env, revision, path)
            })
            .await?;
        let ctx = helper::StderrCtx {
            revision,
            path: Some(path),
        };
        let output = cmd
            .run()
            .await
            .map_err(|e| helper::classify_cmd_error(e, &ctx))?;
        if !output.status.success() {
            return Err(helper::classify_stderr(
                &String::from_utf8_lossy(&output.stderr),
                &ctx,
            ));
        }
        let mut commits = helper::parse_log_porcelain(&output.stdout)?;
        commits
            .pop()
            .ok_or_else(|| BabyError::RevisionNotFound(revision.to_string()))
    }

    async fn spawn_commit_cmd<F>(
        &self,
        rev: &str,
        builder: F,
    ) -> Result<crate::command::cmd::Cmd, BabyError>
    where
        F: FnOnce(&Path, crate::command::env::Env) -> crate::command::cmd::Cmd,
    {
        let _ = rev;
        let dir = self
            .facade
            .git_repo_dir()
            .await
            .map_err(helper::facade_error)?;
        let alternates = self
            .facade
            .git_alternate_object_directories()
            .await
            .map_err(helper::facade_error)?;
        let env = helper::build_env(&alternates);
        Ok(builder(&dir, env))
    }
}

use crate::command::error::CmdError;