use std::ops::{Div, Mul};
use std::os::unix::fs::PermissionsExt;
use std::path::Path;

#[derive(thiserror::Error, Debug)]
enum FilesUtilsError {
    #[error("UnitConvertError: {0}")]
    UnitConvert(String),
}

const INVALID_CHARS: [&str; 19] = [
    "@", "\\", "/", ":", ",", "<", ">", "%", "'", "\"", "?", "{", "}", "$", "*", "|", ";", "=",
    "\t",
];

/// Check out whether a file name is valid or not
pub fn check_file_name(name: &str) -> bool {
    !name.is_empty() && !INVALID_CHARS.iter().any(|c| name.contains(c))
}

/// Create directory if missing
pub fn create_directory_if_missing<P: AsRef<Path>>(path: P) -> anyhow::Result<()> {
    let path = path.as_ref();
    if !path.exists() {
        std::fs::create_dir_all(path)?;
    }
    Ok(())
}

/// Update file permission
pub fn set_file_permission<P: AsRef<Path>>(path: P, mode: u32) -> anyhow::Result<()> {
    let mut perms = std::fs::metadata(path.as_ref())?.permissions();
    perms.set_mode(mode);
    std::fs::set_permissions(path.as_ref(), perms)?;
    Ok(())
}

/// Convert size unit to MB
pub fn convert_size_unit_to_mb(unit: &str, value: usize) -> anyhow::Result<usize> {
    let fact = match unit {
        "bytes" | "b" => 1f64,
        "KB" => 1000f64,
        "MB" => 1000f64 * 1000f64,
        "GB" => 1000f64 * 1000f64 * 1000f64,
        "TB" => 1000f64 * 1000f64 * 1000f64 * 1000f64,

        "k" | "KiB" => 1024f64,
        "M" | "MiB" => 1024f64 * 1024f64,
        "G" | "GiB" => 1024f64 * 1024f64 * 1024f64,
        "T" | "TiB" => 1024f64 * 1024f64 * 1024f64 * 1024f64,

        _ => {
            return Err(FilesUtilsError::UnitConvert(format!("Unknown size unit: {unit}")).into());
        }
    };

    Ok((value as f64).mul(fact.div((1000 * 1000) as f64)).ceil() as usize)
}

#[cfg(test)]
mod test {
    use crate::utils::files_utils::{check_file_name, convert_size_unit_to_mb};

    #[test]
    fn empty_file_name() {
        assert!(!check_file_name(""));
    }

    #[test]
    fn parent_dir_file_name() {
        assert!(!check_file_name("../file.test"));
    }

    #[test]
    fn windows_parent_dir_file_name() {
        assert!(!check_file_name("..\\test.fr"));
    }

    #[test]
    fn special_char_file_name() {
        assert!(!check_file_name("test:test.@"));
    }

    #[test]
    fn valid_file_name() {
        assert!(check_file_name("test.iso"));
    }

    #[test]
    fn convert_units_mb() {
        assert_eq!(convert_size_unit_to_mb("MB", 1).unwrap(), 1);
        assert_eq!(convert_size_unit_to_mb("MB", 1000).unwrap(), 1000);
        assert_eq!(convert_size_unit_to_mb("GB", 1000).unwrap(), 1000 * 1000);
        assert_eq!(convert_size_unit_to_mb("GB", 1).unwrap(), 1000);
        assert_eq!(convert_size_unit_to_mb("GiB", 3).unwrap(), 3222);
        assert_eq!(convert_size_unit_to_mb("KiB", 488281).unwrap(), 500);
    }
}