use std::{
    cmp::Ordering,
    collections::{BTreeMap, BTreeSet},
    ffi::OsStr,
    io::Write,
    path::{Path, PathBuf},
    process::{Command, Stdio},
};

use bstr::{BString, ByteSlice};
use gix_hash::{Kind, ObjectId};

use super::{Commit, Head, IndexEntry, Reference, ReferenceTarget, State};
use crate::Result;

pub(super) fn snapshot(path: &Path) -> Result<State> {
    let hash = object_hash(path)?;
    let common_dir = common_dir(path)?;
    let config = std::fs::read(common_dir.join("config"))?.into();
    let symbolic_head = git_optional(path, ["symbolic-ref", "-q", "HEAD"])?.map(|out| out.trim().to_owned());
    let head_id = git_optional(path, ["rev-parse", "--verify", "HEAD"])?
        .map(|out| parse_id(out.trim(), hash))
        .transpose()?;
    let head = match (symbolic_head, head_id) {
        (Some(name), Some(id)) => Head::Symbolic { name: name.into(), id },
        (Some(name), None) => Head::Unborn(name.into()),
        (None, Some(id)) => Head::Detached(id),
        (None, None) => return Err("HEAD is neither symbolic, detached, nor unborn".into()),
    };
    let (references, mut roots) = references(path, hash)?;
    roots.extend(head_id);
    let shallow = shallow_commits(path, hash)?;
    let commits = commits(path, roots, hash, &shallow)?;
    let index = index(path, hash)?;
    let index_tree = index_tree(path, &index, hash)?;
    let worktree_root = worktree_root(path)?;
    let worktree = super::worktree(worktree_root.as_deref())?;
    Ok(State {
        head,
        config,
        references,
        commits,
        index,
        index_tree,
        worktree,
        normalization_root: common_dir,
        show_object_ids: false,
    })
}

fn object_hash(path: &Path) -> Result<Kind> {
    match git(path, ["rev-parse", "--show-object-format"])?.trim() {
        #[cfg(feature = "sha1")]
        b"sha1" => Ok(Kind::Sha1),
        #[cfg(feature = "sha256")]
        b"sha256" => Ok(Kind::Sha256),
        value => Err(format!("unsupported object format: {}", value.as_bstr()).into()),
    }
}

fn references(path: &Path, hash: Kind) -> Result<(Vec<Reference>, Vec<ObjectId>)> {
    let output = git(
        path,
        [
            "for-each-ref",
            "--format=%(refname)%00%(symref)%00%(objectname)",
            "refs/",
        ],
    )?;
    let mut out = Vec::new();
    let mut roots = Vec::new();
    for record in output.lines().filter(|line| !line.is_empty()) {
        let mut fields = record.split(|byte| *byte == 0);
        let name = fields.next().ok_or("reference output lacks a name")?;
        let symbolic = fields.next().ok_or("reference output lacks a symbolic target")?;
        let id = fields.next().ok_or("reference output lacks an object target")?;
        let resolved = (!id.is_empty()).then(|| parse_id(id, hash)).transpose()?;
        roots.extend(resolved);
        let target = if symbolic.is_empty() {
            ReferenceTarget::Object(resolved.ok_or("a direct reference lacks an object target")?)
        } else {
            ReferenceTarget::Symbolic(symbolic.into())
        };
        out.push(Reference {
            name: name.into(),
            target,
        });
    }
    out.sort_by(|a, b| a.name.cmp(&b.name));
    Ok((out, roots))
}

fn common_dir(path: &Path) -> Result<PathBuf> {
    let common_dir = git(path, ["rev-parse", "--git-common-dir"])?;
    let common_dir = PathBuf::from(String::from_utf8(common_dir.trim().to_owned())?);
    Ok(if common_dir.is_absolute() {
        common_dir
    } else {
        path.join(common_dir)
    })
}

fn shallow_commits(path: &Path, hash: Kind) -> Result<BTreeSet<ObjectId>> {
    let data = match std::fs::read(common_dir(path)?.join("shallow")) {
        Ok(data) => data,
        Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(BTreeSet::new()),
        Err(err) => return Err(err.into()),
    };
    data.lines().map(|line| parse_id(line, hash)).collect()
}

fn commits(path: &Path, roots: Vec<ObjectId>, hash: Kind, shallow: &BTreeSet<ObjectId>) -> Result<Vec<Commit>> {
    let mut pending = Vec::new();
    for id in roots {
        if let Some(id) = peel_to_commit(path, id, hash)? {
            pending.push(id);
        }
    }
    let mut seen = BTreeSet::new();
    let mut commits = Vec::new();
    while let Some(id) = pending.pop() {
        if !seen.insert(id) {
            continue;
        }
        let hex = id.to_string();
        let data = git(path, ["cat-file", "commit", &hex])?;
        if !shallow.contains(&id) {
            for parent in data
                .lines()
                .take_while(|line| !line.is_empty())
                .filter_map(|line| line.strip_prefix(b"parent "))
            {
                pending.push(parse_id(parent, hash)?);
            }
        }
        commits.push(Commit { id, data });
    }
    commits.sort_by_key(|commit| commit.id);
    Ok(commits)
}

fn peel_to_commit(path: &Path, mut id: ObjectId, hash: Kind) -> Result<Option<ObjectId>> {
    let mut seen = BTreeSet::new();
    loop {
        if !seen.insert(id) {
            return Err(format!("tag cycle at {id}").into());
        }
        let hex = id.to_string();
        match git(path, ["cat-file", "-t", &hex])?.trim() {
            b"commit" => return Ok(Some(id)),
            b"tag" => {
                let data = git(path, ["cat-file", "tag", &hex])?;
                let target = data
                    .lines()
                    .next()
                    .and_then(|line| line.strip_prefix(b"object "))
                    .ok_or("tag object lacks its target")?;
                id = parse_id(target, hash)?;
            }
            _ => return Ok(None),
        }
    }
}

fn index(path: &Path, hash: Kind) -> Result<Vec<IndexEntry>> {
    let output = git(path, ["ls-files", "--stage", "-z"])?;
    output
        .split(|byte| *byte == 0)
        .filter(|record| !record.is_empty())
        .map(|record| {
            let (metadata, path) = record.split_once_str(b"\t").ok_or("index entry lacks a path")?;
            let mut fields = metadata.split(|byte| *byte == b' ');
            let mode = u32::from_str_radix(
                std::str::from_utf8(fields.next().ok_or("index entry lacks a mode")?)?,
                8,
            )?;
            let id = parse_id(fields.next().ok_or("index entry lacks an object ID")?, hash)?;
            let stage = std::str::from_utf8(fields.next().ok_or("index entry lacks a stage")?)?.parse::<u8>()?;
            Ok(IndexEntry {
                mode,
                id,
                stage,
                path: path.into(),
            })
        })
        .collect()
}

#[derive(Default)]
struct Tree {
    entries: BTreeMap<BString, TreeEntry>,
}

enum TreeEntry {
    Tree(Tree),
    Leaf { mode: u32, id: ObjectId },
}

fn index_tree(path: &Path, entries: &[IndexEntry], hash: Kind) -> Result<Option<ObjectId>> {
    if entries.iter().any(|entry| entry.stage != 0) {
        return Ok(None);
    }
    let mut root = Tree::default();
    for entry in entries {
        insert(&mut root, entry.path.as_ref(), entry.mode, entry.id)?;
    }
    Ok(Some(hash_tree(path, &root, hash)?))
}

fn insert(tree: &mut Tree, path: &[u8], mode: u32, id: ObjectId) -> Result<()> {
    let mut components = path.split(|byte| *byte == b'/').peekable();
    let mut tree = tree;
    while let Some(component) = components.next() {
        if components.peek().is_none() {
            tree.entries.insert(component.into(), TreeEntry::Leaf { mode, id });
            return Ok(());
        }
        tree = match tree
            .entries
            .entry(component.into())
            .or_insert_with(|| TreeEntry::Tree(Tree::default()))
        {
            TreeEntry::Tree(tree) => tree,
            TreeEntry::Leaf { .. } => return Err("an index path traverses a non-tree entry".into()),
        };
    }
    Err("an index entry has an empty path".into())
}

fn hash_tree(path: &Path, tree: &Tree, hash: Kind) -> Result<ObjectId> {
    let mut entries: Vec<_> = tree.entries.iter().collect();
    entries.sort_by(|(a, a_entry), (b, b_entry)| tree_name_cmp(a, a_entry, b, b_entry));
    let mut data = Vec::new();
    for (name, entry) in entries {
        let (mode, id) = match entry {
            TreeEntry::Tree(tree) => (0o40000, hash_tree(path, tree, hash)?),
            TreeEntry::Leaf { mode, id } => (*mode, *id),
        };
        data.extend_from_slice(format!("{mode:o}").as_bytes());
        data.push(b' ');
        data.extend_from_slice(name);
        data.push(0);
        data.extend_from_slice(id.as_bytes());
    }
    let id = git_with_input(path, ["hash-object", "-t", "tree", "--stdin"], &data)?;
    parse_id(id.trim(), hash)
}

fn tree_name_cmp(a: &[u8], a_entry: &TreeEntry, b: &[u8], b_entry: &TreeEntry) -> Ordering {
    let mut a = a
        .iter()
        .copied()
        .chain(std::iter::once(if matches!(a_entry, TreeEntry::Tree(_)) {
            b'/'
        } else {
            0
        }));
    let mut b = b
        .iter()
        .copied()
        .chain(std::iter::once(if matches!(b_entry, TreeEntry::Tree(_)) {
            b'/'
        } else {
            0
        }));
    loop {
        match (a.next(), b.next()) {
            (Some(a), Some(b)) if a == b => {}
            (Some(a), Some(b)) => return a.cmp(&b),
            (None, None) => return Ordering::Equal,
            (None, Some(_)) => return Ordering::Less,
            (Some(_), None) => return Ordering::Greater,
        }
    }
}

fn worktree_root(path: &Path) -> Result<Option<PathBuf>> {
    git_optional(path, ["rev-parse", "--show-toplevel"])?
        .map(|root| String::from_utf8(root.trim().to_owned()).map(PathBuf::from))
        .transpose()
        .map_err(Into::into)
}

fn parse_id(input: &[u8], hash: Kind) -> Result<ObjectId> {
    let id = ObjectId::from_hex(input)?;
    if id.kind() != hash {
        return Err("object ID uses the wrong hash kind".into());
    }
    Ok(id)
}

fn git<const N: usize>(path: &Path, args: [&str; N]) -> Result<Vec<u8>> {
    git_os(path, args.iter().map(OsStr::new))
}

fn git_os<'a>(path: &Path, args: impl IntoIterator<Item = &'a OsStr>) -> Result<Vec<u8>> {
    let output = Command::new(gix_path::env::exe_invocation())
        .arg("-C")
        .arg(path)
        .args(args)
        .env("GIT_OPTIONAL_LOCKS", "0")
        .env("GIT_NO_REPLACE_OBJECTS", "1")
        .output()?;
    if output.status.success() {
        return Ok(output.stdout);
    }
    Err(format!(
        "git command failed with {}: {}",
        output.status,
        output.stderr.as_bstr().trim().as_bstr()
    )
    .into())
}

fn git_with_input<const N: usize>(path: &Path, args: [&str; N], input: &[u8]) -> Result<Vec<u8>> {
    let mut child = Command::new(gix_path::env::exe_invocation())
        .arg("-C")
        .arg(path)
        .args(args)
        .env("GIT_OPTIONAL_LOCKS", "0")
        .env("GIT_NO_REPLACE_OBJECTS", "1")
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()?;
    child.stdin.take().expect("configured as piped").write_all(input)?;
    let output = child.wait_with_output()?;
    if output.status.success() {
        return Ok(output.stdout);
    }
    Err(format!(
        "git command failed with {}: {}",
        output.status,
        output.stderr.as_bstr().trim().as_bstr()
    )
    .into())
}

fn git_optional<const N: usize>(path: &Path, args: [&str; N]) -> Result<Option<Vec<u8>>> {
    let output = Command::new(gix_path::env::exe_invocation())
        .arg("-C")
        .arg(path)
        .args(args)
        .env("GIT_OPTIONAL_LOCKS", "0")
        .env("GIT_NO_REPLACE_OBJECTS", "1")
        .output()?;
    Ok(output.status.success().then_some(output.stdout))
}