use std::io::Write;
use std::path::PathBuf;

use std::fs::File;
use std::io;
use std::io::{Read, Write};
use std::path::{Path, PathBuf};

use anyhow::bail;

use anyhow::anyhow;

#[derive(Debug, Serialize, Deserialize)]

#[derive(Debug, Default, Serialize, Deserialize)]

fn try_load_file(path: impl Into<PathBuf> + AsRef<Path>) -> Option<(io::Result<File>, PathBuf)> {
    let pp = path.as_ref();
    match File::open(pp) {
        Ok(v) => Some((Ok(v), path.into())),
        Err(e) if e.kind() == io::ErrorKind::NotFound => None,
        Err(e) => Some((Err(e), path.into())),
    }
}

    pub fn load() -> Result<(Global, u64), anyhow::Error> {
        if let Some(mut dir) = global_config_dir() {
            dir.push("config.toml");
            let (s, meta) = std::fs::read(&dir)
                .and_then(|x| Ok((x, std::fs::metadata(&dir)?)))
                .or_else(|e| {
                    // Read from `$HOME/.config/pijul` dir
                    if let Some(mut dir) = dirs_next::home_dir() {
                        dir.push(".config");
                        dir.push(CONFIG_DIR);
                        dir.push("config.toml");
                        std::fs::read(&dir).and_then(|x| Ok((x, std::fs::metadata(&dir)?)))
                    } else {
                        Err(e.into())
                    }
                })
                .or_else(|e| {
                    // Read from `$HOME/.pijulconfig`
                    if let Some(mut dir) = dirs_next::home_dir() {
                        dir.push(GLOBAL_CONFIG_DIR);
                        std::fs::read(&dir).and_then(|x| Ok((x, std::fs::metadata(&dir)?)))
                    } else {
                        Err(e.into())
                    }
                })?;
            debug!("s = {:?}", s);
            if let Ok(t) = toml::from_slice(&s) {
                let ts = meta
                    .modified()?
                    .duration_since(std::time::SystemTime::UNIX_EPOCH)
                    .unwrap()
                    .as_secs();
                Ok((t, ts))
            } else {
                bail!("Could not read configuration file at {:?}", dir)
            }
        } else {
            bail!("Global configuration file missing")
        }

    pub fn load() -> Result<(Global, Option<u64>), anyhow::Error> {
        let res = None
            .or_else(|| {
                let mut path = global_config_dir()?;
                path.push("config.toml");
                try_load_file(path)
            })
            .or_else(|| {
                // Read from `$HOME/.config/pijul` dir
                let mut path = dirs_next::home_dir()?;
                path.push(".config");
                path.push(CONFIG_DIR);
                path.push("config.toml");
                try_load_file(path)
            })
            .or_else(|| {
                // Read from `$HOME/.pijulconfig`
                let mut path = dirs_next::home_dir()?;
                path.push(GLOBAL_CONFIG_DIR);
                try_load_file(path)
            });
        let Some((file, path)) = res else {
            return Ok((Global::default(), None));
        };
        let mut file = file.map_err(|e| {
            anyhow!("Could not open configuration file at {}", path.display()).context(e)
        })?;
        let mut buf = String::new();
        file.read_to_string(&mut buf).map_err(|e| {
            anyhow!("Could not read configuration file at {}", path.display()).context(e)
        })?;
        debug!("buf = {:?}", buf);
        let global: Global = toml::from_str(&buf).map_err(|e| {
            anyhow!("Could not parse configuration file at {}", path.display()).context(e)
        })?;
        let metadata = file.metadata()?;
        let file_age = metadata
            .modified()?
            .duration_since(std::time::SystemTime::UNIX_EPOCH)?
            .as_secs();
        Ok((global, Some(file_age)))