use std::fs::File;
use std::io::Write;

pub const CONFIG_FILE: &str = "config";
const DEFAULT_IGNORE: [&[u8]; 2] = [b".git", b".DS_Store"];
// Static KV map of names for project kinds |-> elements
// that should go in the `.ignore` file by default.
const IGNORE_KINDS: &[(&[&str], &[&[u8]])] = &[
    (&["rust"], &[b"/target", b"Cargo.lock"]),
    (&["node", "nodejs"], &[b"node_modules"]),
    (&["lean"], &[b"/build"]),
];

        use std::io::Write;

            init_dot_ignore(config, &cur, kind)?;

            let dot_ignore_path = cur.join(".ignore");
            // Initialize the `.ignore` file, if it doesn't already exist
            if !dot_ignore_path.exists() {
                let mut dot_ignore_file = File::create_new(&dot_ignore_path)?;
                let file_contents = config.dot_ignore_contents(kind)?;
                dot_ignore_file.write_all(file_contents.as_bytes())?;
            }

        }
    }
}
/// Create and populate an initial `.ignore` file for the repository.
/// The default elements are defined in the constant [`DEFAULT_IGNORE`].
fn init_dot_ignore(
    config: &pijul_config::Config,
    base_path: &Path,
    kind: Option<&str>,
) -> Result<(), anyhow::Error> {
    use std::io::Write;
    let dot_ignore_path = base_path.join(".ignore");
    // Don't replace/modify an existing `.ignore` file.
    if dot_ignore_path.exists() {
        Ok(())
    } else {
        let mut dot_ignore = std::fs::OpenOptions::new()
            .read(true)
            .write(true)
            .create(true)
            .open(dot_ignore_path)?;
        for default_ignore in DEFAULT_IGNORE.iter() {
            dot_ignore.write_all(default_ignore)?;
            dot_ignore.write_all(b"\n")?;

        ignore_specific(config, &mut dot_ignore, kind)

/// if `kind` matches any of the known project kinds, add the associated
/// .ignore entries to the default `.ignore` file.
fn ignore_specific(
    config: &pijul_config::Config,
    dot_ignore: &mut std::fs::File,
    kind: Option<&str>,
) -> Result<(), anyhow::Error> {
    use std::io::Write;
    if let Some(kind) = kind {
        if let Some(kinds) = config.ignore_kinds.get(kind) {
            for entry in kinds.iter() {
                writeln!(dot_ignore, "{}", entry)?;
            }
            return Ok(());
        }
        let entries = IGNORE_KINDS
            .iter()
            .find(|(names, _)| names.iter().any(|x| kind.eq_ignore_ascii_case(x)))
            .into_iter()
            .flat_map(|(_, v)| v.iter());
        for entry in entries {
            dot_ignore.write_all(entry)?;
            dot_ignore.write_all(b"\n")?;
        }
    }
    Ok(())
}

use log::warn;

use log::warn;

pub const DEFAULT_CONFIG: &str = include_str!("defaults.toml");

        // 1. Global config

        // 1. Included defaults (defaults.toml)
        layers = layers.merge(Toml::string(DEFAULT_CONFIG));
        // 2. Global config

        // 2. Local config

        // 3. Local config

    pub fn dot_ignore_contents(&self, ignore_kind: Option<&str>) -> Result<String, anyhow::Error> {
        // The default entry is guaranteed to be present
        let default_ignore_lines = self.ignore_kinds.get("default").unwrap();

        // Find any extra lines to add to the `.ignore`, if they exist
        let extra_ignore_lines = match ignore_kind {
            Some(kind) => match self.ignore_kinds.get(kind) {
                Some(extra_ignore_lines) => extra_ignore_lines.iter(),
                None => {
                    return Err(anyhow::anyhow!(
                        "Unable to find specific ignore kind: {kind}"
                    ));
                }
            },
            None => [].iter(),
        };
        // Merge the default and specific ignore lines
        let mut ignore_lines = default_ignore_lines
            .iter()
            .chain(extra_ignore_lines)
            .map(|line| line.as_str())
            .collect::<Vec<_>>()
            .join("\n");
        // Add a newline at the end of the file
        if !ignore_lines.is_empty() {
            ignore_lines.push('\n');
        }
        Ok(ignore_lines)
    }

# Default configuration values
[ignore_kinds]
default = [".git", ".DS_Store"]
rust = ["/target", "Cargo.lock"]
node = ["nodejs", "node_modules"]
lean = ["/build"]