mod config;
mod desktops;
mod environment;
mod error;
mod fileinfo;
mod pids;
mod traits;
mod walkdir;

pub use self::{
    config::*, desktops::*, environment::*, error::*, fileinfo::*, pids::*, traits::*, walkdir::*,
};

// https://crates.io/crates/cfg-if
cfg_if::cfg_if! {
    if #[cfg(feature = "args_v2")] {
        mod args_v2;
        pub use args_v2::*;
    } else {
        // default: use "clap"
        mod args_v1;
        pub use args_v1::*;
    }
}

// use rayon::prelude::*;
use std::{collections::HashSet, env, thread};

pub type MyError = Box<dyn std::error::Error + Send + Sync>;
pub type MyResult<T> = Result<T, MyError>;

/// Show initial messages
pub fn show_initial_msgs(config: &Config) -> MyResult<()> {
    let pkg_name = ENVIRON.get_pkg_name();
    let pkg_desc = env!("CARGO_PKG_DESCRIPTION");
    let pkg_version = env!("CARGO_PKG_VERSION");
    let interval = config.interval;
    let info = format!("Interval between each wallpaper: {interval} seconds.");
    let author = "Claudio Fernandes de Souza Rodrigues (claudiofsrodrigues@gmail.com)";

    println!("{pkg_name} {pkg_desc}\n{info}\n{author}");
    println!("version: {pkg_version}\n");

    let depend1 = "imagemagick (image viewing/manipulation program)";
    let depend2 = "feh (fast and light image viewer)";
    let dependencies = [depend1, depend2];

    println!("Dependencies:");
    dependencies.print_with_spaces(" ");
    println!();

    config.print()?;

    Ok(())
}

/// Get unique and random images/figures
pub fn get_images(config: &Config, args: &Arguments) -> MyResult<Vec<FileInfo>> {
    let mut files: HashSet<FileInfo> = HashSet::new();

    for dir in &config.dirs {
        let infos: Vec<FileInfo> = get_all_files(dir, config)?;
        files.extend(infos);
    }

    if files.is_empty() {
        eprintln!("Image directories:");
        config.dirs.print_with_spaces(" ");
        panic!("Error: no images found in directories!");
    }

    let nfiles = files.len();

    if nfiles < (args.monitor as usize) {
        eprintln!("Image files:\n{files:#?}\n");
        panic!("Error: found only {nfiles} image file(s)!");
    }

    let mut values: Vec<FileInfo> = files.into_iter().collect();

    if args.sort {
        values.sort_by_key(|f| f.path.clone());
    }

    Ok(values)
}

/// Display found images
pub fn display_files(files: &[FileInfo], args: &Arguments) {
    let nfiles = files.len();
    let ndigits = count_digits(nfiles);

    if args.sort {
        println!("{nfiles} images were found (sorted):");
    } else {
        println!("{nfiles} images were found (shuffled):");
    }

    for (index, image) in files.iter().enumerate() {
        println!(
            "images[{n:0ndigits$}]: {p:?}",
            n = index + 1,
            p = image.path
        );
    }
    println!();
}

/// Get the length of the usize integer
///
/// <https://doc.rust-lang.org/std/primitive.usize.html#method.checked_ilog10>
pub fn count_digits(value: usize) -> usize {
    match value.checked_ilog10() {
        Some(num) => (num + 1) as usize,
        None => value.to_string().len(),
    }
}

/**
Update FileInfo images with dimension information

Parallelize the computation using std::thread::scope

<https://stackoverflow.com/questions/74590440/how-do-i-change-the-structure-in-the-thread>
*/
pub fn update_images(
    files: &[FileInfo],
    config: &Config,
    args: &Arguments,
) -> MyResult<Vec<FileInfo>> {
    let mut owned_files: Vec<FileInfo> = files.to_vec();

    thread::scope(|scope| {
        for file in &mut owned_files {
            scope.spawn(move || -> MyResult<()> {
                //let id = thread::current().id();
                //println!("identifier thread: {id:?}");
                file.update_info(config, args)?;
                Ok(())
            });
        }
    });

    Ok(owned_files)
}

/*
pub fn update_images_v2(
    files: &[FileInfo],
    config: &Config,
    args: &Arguments,
) -> MyResult<Vec<FileInfo>> {
    let mut owned_files: Vec<FileInfo> = files.to_vec();

    thread::scope(|scope| {
        let mut threads = Vec::new();

        for file in &mut owned_files {
            threads.push(scope.spawn(move || -> MyResult<()> {
                //let id = thread::current().id();
                //println!("identifier thread: {id:?}");
                file.update_info(config, args)?;
                Ok(())
            }));
        }

        for thread in threads {
            let _result = thread.join();
        }
    });

    Ok(owned_files)
}

pub fn update_images_v3(
    files: &[FileInfo],
    config: &Config,
    args: &Arguments,
) -> MyResult<Vec<FileInfo>> {
    files
        .iter() // Sequential computing
        //.par_iter() // Parallelize the computation using rayon
        .cloned()
        .map(|mut file| -> MyResult<FileInfo> {
            //let thread = rayon::current_thread_index();
            //println!("rayon thread id {:?}", thread);
            file.update_info(config, args)?;
            Ok(file)
        })
        .collect()
}
*/