use crate::{bstr::BString, permission};

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("Could not open repository conifguration file")]
    Open(#[from] git_config::parser::ParserOrIoError<'static>),
    #[error("Cannot handle objects formatted as {:?}", .name)]
    UnsupportedObjectFormat { name: crate::bstr::BString },
    #[error("The value for '{}' cannot be empty", .key)]
    EmptyValue { key: &'static str },
    #[error("Invalid value for 'core.abbrev' = '{}'. It must be between 4 and {}", .value, .max)]
    CoreAbbrev { value: BString, max: u8 },
    #[error("Value '{}' at key '{}' could not be decoded as boolean", .value, .key)]
    DecodeBoolean { key: String, value: BString },
    #[error(transparent)]
    PathInterpolation(#[from] git_config::values::path::interpolate::Error),
}

/// Utility type to keep pre-obtained configuration values.
#[derive(Debug, Clone)]
pub(crate) struct Cache {
    pub resolved: crate::Config,
    /// The hex-length to assume when shortening object ids. If `None`, it should be computed based on the approximate object count.
    pub hex_len: Option<usize>,
    /// true if the repository is designated as 'bare', without work tree.
    pub is_bare: bool,
    /// The type of hash to use.
    pub object_hash: git_hash::Kind,
    /// If true, multi-pack indices, whether present or not, may be used by the object database.
    pub use_multi_pack_index: bool,
    /// If true, we are on a case-insensitive file system.
    #[cfg_attr(not(feature = "git-index"), allow(dead_code))]
    pub ignore_case: bool,
    /// The path to the user-level excludes file to ignore certain files in the worktree.
    #[cfg_attr(not(feature = "git-index"), allow(dead_code))]
    pub excludes_file: Option<std::path::PathBuf>,
    /// Define how we can use values obtained with `xdg_config(…)` and its `XDG_CONFIG_HOME` variable.
    #[cfg_attr(not(feature = "git-index"), allow(dead_code))]
    xdg_config_home_env: permission::env_var::Resource,
    /// Define how we can use values obtained with `xdg_config(…)`. and its `HOME` variable.
    #[cfg_attr(not(feature = "git-index"), allow(dead_code))]
    home_env: permission::env_var::Resource,
    // TODO: make core.precomposeUnicode available as well.
}

mod cache {
    use std::{convert::TryFrom, path::PathBuf};

    use git_config::{
        file::GitConfig,
        values::{Boolean, Integer},
    };

    use super::{Cache, Error};
    use crate::{bstr::ByteSlice, permission};

    impl Cache {
        pub fn new(
            git_dir: &std::path::Path,
            xdg_config_home_env: permission::env_var::Resource,
            home_env: permission::env_var::Resource,
            git_install_dir: Option<&std::path::Path>,
        ) -> Result<Self, Error> {
            let config = GitConfig::open(git_dir.join("config"))?;

            let is_bare = config_bool(&config, "core.bare", false)?;
            let use_multi_pack_index = config_bool(&config, "core.multiPackIndex", true)?;
            let ignore_case = config_bool(&config, "core.ignorecase", false)?;
            let excludes_file = config
                .path("core", None, "excludesFile")
                .map(|p| p.interpolate(git_install_dir).map(|p| p.into_owned()))
                .transpose()?;
            let repo_format_version = config
                .value::<Integer>("core", None, "repositoryFormatVersion")
                .map_or(0, |v| v.value);
            let object_hash = (repo_format_version != 1)
                .then(|| Ok(git_hash::Kind::Sha1))
                .or_else(|| {
                    config
                        .raw_value("extensions", None, "objectFormat")
                        .ok()
                        .map(|format| match format.as_ref() {
                            b"sha1" => Ok(git_hash::Kind::Sha1),
                            _ => Err(Error::UnsupportedObjectFormat {
                                name: format.to_vec().into(),
                            }),
                        })
                })
                .transpose()?
                .unwrap_or(git_hash::Kind::Sha1);

            let mut hex_len = None;
            if let Some(hex_len_str) = config.string("core", None, "abbrev") {
                if hex_len_str.trim().is_empty() {
                    return Err(Error::EmptyValue { key: "core.abbrev" });
                }
                if hex_len_str.as_ref() != "auto" {
                    let value_bytes = hex_len_str.as_ref().as_ref();
                    if let Ok(Boolean::False(_)) = Boolean::try_from(value_bytes) {
                        hex_len = object_hash.len_in_hex().into();
                    } else {
                        let value = Integer::try_from(value_bytes)
                            .map_err(|_| Error::CoreAbbrev {
                                value: hex_len_str.clone().into_owned(),
                                max: object_hash.len_in_hex() as u8,
                            })?
                            .to_decimal()
                            .ok_or_else(|| Error::CoreAbbrev {
                                value: hex_len_str.clone().into_owned(),
                                max: object_hash.len_in_hex() as u8,
                            })?;
                        if value < 4 || value as usize > object_hash.len_in_hex() {
                            return Err(Error::CoreAbbrev {
                                value: hex_len_str.clone().into_owned(),
                                max: object_hash.len_in_hex() as u8,
                            });
                        }
                        hex_len = Some(value as usize);
                    }
                }
            }

            Ok(Cache {
                resolved: config.into(),
                use_multi_pack_index,
                object_hash,
                is_bare,
                ignore_case,
                hex_len,
                excludes_file,
                xdg_config_home_env,
                home_env,
            })
        }

        /// Return a path by using the `$XDF_CONFIG_HOME` or `$HOME/.config/…` environment variables locations.
        #[cfg_attr(not(feature = "git-index"), allow(dead_code))]
        pub fn xdg_config_path(
            &self,
            resource_file_name: &str,
        ) -> Result<Option<PathBuf>, git_sec::permission::Error<PathBuf, git_sec::Permission>> {
            std::env::var_os("XDG_CONFIG_HOME")
                .map(|path| (path, &self.xdg_config_home_env))
                .or_else(|| std::env::var_os("HOME").map(|path| (path, &self.home_env)))
                .and_then(|(base, permission)| {
                    let resource = std::path::PathBuf::from(base).join("git").join(resource_file_name);
                    permission.check(resource).transpose()
                })
                .transpose()
        }
    }

    fn config_bool(config: &GitConfig<'_>, key: &str, default: bool) -> Result<bool, Error> {
        let (section, key) = key.split_once('.').expect("valid section.key format");
        config
            .boolean(section, None, key)
            .unwrap_or(Ok(default))
            .map_err(|err| Error::DecodeBoolean {
                value: err.input,
                key: key.into(),
            })
    }
}