//! This module allows creating git blobs from worktree files.
//!
//! For the most part a blob just contains the raw on-disk data. However symlinks need to be considered properly
//! and attributes/config options need to be considered.

use std::{
    fs::{read_link, File},
    io::{self, Read},
    path::Path,
};

use gix_object::Blob;
use gix_path as path;

// TODO: tests

// TODO: what to do about precompose unicode and ignore_case for symlinks

/// Create a blob from a file or symlink.
pub fn blob(path: &Path, capabilities: &gix_fs::Capabilities) -> io::Result<Blob> {
    let mut data = Vec::new();
    data_to_buf(path, &mut data, capabilities)?;
    Ok(Blob { data })
}

/// Create a blob from a file or symlink.
pub fn blob_with_meta(path: &Path, is_symlink: bool, capabilities: &gix_fs::Capabilities) -> io::Result<Blob> {
    let mut data = Vec::new();
    data_to_buf_with_meta(path, &mut data, is_symlink, capabilities)?;
    Ok(Blob { data })
}

/// Create blob data from a file or symlink.
pub fn data_to_buf<'a>(path: &Path, buf: &'a mut Vec<u8>, capabilities: &gix_fs::Capabilities) -> io::Result<&'a [u8]> {
    data_to_buf_with_meta(path, buf, path.symlink_metadata()?.is_symlink(), capabilities)
}

/// Create a blob from a file or symlink.
pub fn data_to_buf_with_meta<'a>(
    path: &Path,
    buf: &'a mut Vec<u8>,
    is_symlink: bool,
    capabilities: &gix_fs::Capabilities,
) -> io::Result<&'a [u8]> {
    buf.clear();
    // symlinks are only stored as actual symlinks if the FS supports it otherwise they are just
    // normal files with their content equal to the linked path (so can be read normally)
    //
    if is_symlink && capabilities.symlink {
        // conversion to bstr can never fail because symlinks are only used
        // on unix (by git) so no reason to use the try version here
        let symlink_path = path::into_bstr(read_link(path)?);
        buf.extend_from_slice(&symlink_path);
        // TODO: there is no reason this should be a clone
        //       std isn't great about allowing users to avoid allocations but we could
        //       simply write our own wrapper around libc::readlink which reuses the
        //       buffer. This would require unsafe code tough (obviously)
    } else {
        buf.clear();
        File::open(path)?.read_to_end(buf)?;
        // TODO apply filters
    }
    Ok(buf.as_slice())
}