#![deny(rust_2018_idioms)]
#![allow(clippy::single_component_path_imports)]
#![allow(clippy::type_complexity)]
#![cfg_attr(docsrs, feature(kcm))]
#![feature(const_for, const_trait_impl)]
#![recursion_limit = "1024"]
//! [![](https://gitlab.com/andrew_ryan/doe/-/raw/master/doe.svg)](https://docs.rs/doe)

#![doc(
    html_logo_url = "https://gitlab.com/andrew_ryan/doe/-/raw/master/html_logo.svg",
    html_favicon_url = "https://gitlab.com/andrew_ryan/doe/-/raw/master/html_favicon.svg"
)]
//!
//! This crate provides various utility functions and modules for performing common tasks in Rust applications. It aims to simplify clipboard operations, file system manipulation, keyboard and mouse input simulation, timer management, and Excel file handling.
//!
//!# Features
//!### ctf
//!```
//!cargo add doe -F ctf
//!```
//!allow you to perform various operations with ease, such as string manipulation, urlencode urldecode,hex encode decode,base43 encode decode, and error management.
//!### clip
//!```
//!cargo add doe -F clip
//!```
//!simplifies clipboard management, enabling you to effortlessly interact with the system clipboard.
//!### mouse
//!```
//!cargo add doe -F mouse
//!```
//!offers intuitive and easy-to-use functions for simulating mouse actions.
//!### keyboard
//!```
//!cargo add doe -F keyboard
//!```
//!offers simulating keyboard input action with easy-to-use functions.
//!### clip
//!set and get clipboard text
//!```
//!cargo add doe -F clip
//!```
//!### kcm
//!kcm is short feature for keyboard clipboard mouse together
//!```
//!cargo add doe -F kcm
//!```
//!### xlsx
//!read edit write xlsx file
//!```
//!cargo add doe -F xlsx
//!```
//!### docx
//!read edit docx file
//!```
//!cargo add doe -F docx
//!```

/// clipboard module provides functions and structs related to clipboard operations. It allows the user to copy and paste data between the application and the clipboard.
pub mod clipboard;
/// ctf module provides utility functions like `permutations`,`hex_encode`,`hex_decode`,`base64_encode`,`base64_decode`,`php_urlencode`,`php_urldecode`.
pub mod ctf;
///xlsx module contains functions for reading editing docx file
pub mod docx;
/// The file system (fs) module provides functions and structs for performing operations on the file system. It includes functions for reading, writing, creating, and deleting files and directories.
pub mod fs;
///keyboard module contains functions and structs related to keyboard input. It allows the user to simulate keyboard input, capture keystrokes, and perform other keyboard-related operations.
pub mod keyboard;
///macros module contains all utility macros for development
pub mod macros;
/// mouse module contains functions and structs related to mouse input. It allows the user to simulate mouse input, capture mouse movements and clicks, and perform other mouse-related operations.
pub mod mouse;
///structs module contains definitions of custom data structures like `Bfn`, `Bts`, `waker_fn`.
pub mod structs;
/// timer module provides functions and structs for creating and managing timers. It allows the user to schedule tasks to be executed at a specific time or interval.
pub mod timer;
///traits module contains trait definitions that define shared behavior and functions
pub mod traits;
///xlsx module contains functions and structs for reading, writing, and manipulating Excel files in the XLSX format.
pub mod xlsx;

pub use fs::fs::*;
pub use macros::macros::*;
pub use structs::structs::*;
pub use timer::impl_timer::*;
pub use traits::traits::*;

use std::sync::Arc;

pub type DynError = Result<(), Box<dyn std::error::Error>>;
///Rust is a wrapper for the standard library's std::process::Command function, which is used to execute external commands
///```rust
///     doe::system("ls");
///     doe::system("ls -a");
/// ```
pub fn system(command: impl ToString) -> std::io::Result<()> {
    use std::process::Command;
    if cfg!(target_os = "windows") {
        if crate::has_powershell!() {
            Command::new("powershell")
                .arg("-Command")
                .arg(&command.to_string())
                .status()?;
        } else {
            Command::new("cmd")
                .arg("/c")
                .arg(&command.to_string())
                .status()?;
        }
    } else {
        Command::new("sh")
            .arg("-c")
            .arg(&command.to_string())
            .status()?;
    }
    Ok(())
}

pub fn lowercase_letters() -> Arc<str> {
    Arc::from("abcdefghijklmnopqrstuvwxyz")
}
pub fn uppercase_letters() -> Arc<str> {
    Arc::from("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
}

pub fn digits() -> Arc<str> {
    Arc::from("0123456789")
}

pub fn letters_and_digits() -> Arc<str> {
    Arc::from(format!("{}{}{}", lowercase_letters(), uppercase_letters(), digits()).as_ref())
}

///The Vec sort all elements can be repeated to define the longest shortest size
/// ```ignore
///fn main() {
///     use doe::DebugPrint;
///     use doe::utils::generate_all_possible_vec;
///    let v  = generate_all_possible_vec(&vec![1,2,3],1,2);
///    v.dprintln();//[[1, 1], [1, 2], [1, 3], [2, 1], [2, 2], [2, 3], [3, 1], [3, 2], [3, 3]]
///}
///```
pub fn generate_all_possible_vec<T: Clone>(
    elements: &[T],
    min_len: usize,
    max_len: usize,
) -> Vec<Vec<T>> {
    let mut result = Vec::new();
    for len in min_len..=max_len {
        let mut indices = vec![0; len];
        let mut done = false;
        while !done {
            let permutation = indices.iter().map(|&i| elements[i].clone()).collect();
            result.push(permutation);
            done = true;
            for i in (0..len).rev() {
                indices[i] += 1;
                if indices[i] == elements.len() {
                    indices[i] = 0;
                } else {
                    done = false;
                    break;
                }
            }
        }
    }
    result
}
///permutations
/// ```ignore
///fn main() {
///    use doe::utils::permutations;
///    use doe::DebugPrint;
///    permutations("abc").dprintln();//["abc", "acb", "bac", "bca", "cba", "cab"]
///}
/// ```
pub fn permutations(alphabet: &str) -> Vec<String> {
    fn permute(chars: &mut [char], start: usize, result: &mut Vec<String>) {
        if start == chars.len() {
            result.push(chars.iter().collect());
        } else {
            for i in start..chars.len() {
                chars.swap(start, i);
                permute(chars, start + 1, result);
                chars.swap(start, i);
            }
        }
    }

    let mut result = Vec::new();
    let mut chars: Vec<char> = alphabet.chars().collect();
    permute(&mut chars, 0, &mut result);
    result
}