use std::{convert::TryInto, fs::OpenOptions, io::Write, time::Duration};

use bstr::BStr;
use git_hash::oid;
use git_index::Entry;

use crate::index;
use crate::index::checkout::PathCache;

#[cfg_attr(not(unix), allow(unused_variables))]
pub fn checkout<Find>(
    entry: &mut Entry,
    entry_path: &BStr,
    find: &mut Find,
    cache: &mut PathCache,
    index::checkout::Options {
        fs: crate::fs::Capabilities {
            symlink,
            executable_bit,
            ..
        },
        destination_is_initially_empty,
        ..
    }: index::checkout::Options,
    buf: &mut Vec<u8>,
) -> Result<usize, index::checkout::Error>
where
    Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Option<git_object::BlobRef<'a>>,
{
    let dest = cache.append_relative_path_assure_leading_dir(
        git_features::path::from_byte_slice(entry_path).map_err(|_| index::checkout::Error::IllformedUtf8 {
            path: entry_path.to_owned(),
        })?,
        entry.mode,
    )?;

    let object_size = match entry.mode {
        git_index::entry::Mode::FILE | git_index::entry::Mode::FILE_EXECUTABLE => {
            let obj = find(&entry.id, buf).ok_or_else(|| index::checkout::Error::ObjectNotFound {
                oid: entry.id,
                path: dest.to_path_buf(),
            })?;
            let mut options = OpenOptions::new();
            options
                .create_new(destination_is_initially_empty)
                .create(!destination_is_initially_empty)
                .write(true);
            #[cfg(unix)]
            if executable_bit && entry.mode == git_index::entry::Mode::FILE_EXECUTABLE {
                use std::os::unix::fs::OpenOptionsExt;
                options.mode(0o777);
            }

            let mut file = options.open(&dest)?;
            file.write_all(obj.data)?;
            // NOTE: we don't call `file.sync_all()` here knowing that some filesystems don't handle this well.
            //       revisit this once there is a bug to fix.
            update_fstat(entry, file.metadata()?)?;
            obj.data.len()
        }
        git_index::entry::Mode::SYMLINK => {
            let obj = find(&entry.id, buf).ok_or_else(|| index::checkout::Error::ObjectNotFound {
                oid: entry.id,
                path: dest.to_path_buf(),
            })?;
            let symlink_destination = git_features::path::from_byte_slice(obj.data)
                .map_err(|_| index::checkout::Error::IllformedUtf8 { path: obj.data.into() })?;

            // TODO: how to deal with mode changes? Maybe this info can be passed once we check for whether
            // a checkout is needed at all.
            if symlink {
                crate::os::create_symlink(symlink_destination, dest)?;
            } else {
                std::fs::write(&dest, obj.data)?;
            }

            update_fstat(entry, std::fs::symlink_metadata(&dest)?)?;
            obj.data.len()
        }
        git_index::entry::Mode::DIR => todo!(),
        git_index::entry::Mode::COMMIT => todo!(),
        _ => unreachable!(),
    };
    Ok(object_size)
}

fn update_fstat(entry: &mut Entry, meta: std::fs::Metadata) -> Result<(), index::checkout::Error> {
    let ctime = meta
        .created()
        .map_or(Ok(Duration::default()), |x| x.duration_since(std::time::UNIX_EPOCH))?;
    let mtime = meta
        .modified()
        .map_or(Ok(Duration::default()), |x| x.duration_since(std::time::UNIX_EPOCH))?;

    let stat = &mut entry.stat;
    stat.mtime.secs = mtime
        .as_secs()
        .try_into()
        .expect("by 2038 we found a solution for this");
    stat.mtime.nsecs = mtime.subsec_nanos();
    stat.ctime.secs = ctime
        .as_secs()
        .try_into()
        .expect("by 2038 we found a solution for this");
    stat.ctime.nsecs = ctime.subsec_nanos();
    Ok(())
}