fenir/

lib.rs

#![deny(clippy::mem_forget)]

/// NVD link Rest API for CVE request
pub const NVD_CVE_LINK: &str = "https://services.nvd.nist.gov/rest/json/cves/2.0";

/// NVD api key name to use to by the underlying OS
pub const NVD_KEY_NAME: &str = "NVD_API_KEY";

/// Space substitution in URL
const URL_SPACE: &str = "%20";

/// The `package` module provides all the necessary components
/// for managing and manipulating software packages.
/// This module includes handling errors, defining package concepts,
/// managing facilities, and other related utilities.
pub mod package {
    /// The `concepts` module defines core structures and traits for handling
    /// package information, changelogs, and CVE (Common Vulnerabilities and Exposures) management
    ///
    pub mod concepts {
        pub use crate::cve::Cve;
        use crate::facilities::Uppercase;
        use crate::package::errors::write_error_message_and_exit;
        use crate::{section, section_level};
        use regex::Regex;
        use std::fmt::{Display, Formatter};
        use std::ops::Add;
        use std::process::Output;

        /// Represents a package status that's representing the supported status.
        ///
        #[derive(Eq, PartialEq, Copy, Clone)]
        pub enum PackageStatus {
            /// The package is currently installed on the system.
            Installed,

            /// The package is not found on the system.
            NotFound,

            /// The package has been uninstalled from the system. In some system, this status can be
            /// appearing after a package uninstallation.
            Uninstalled,
        }

        /// The `Package` struct is used to encapsulate information about a software package,
        /// such as the package's name, its version, and its current status in the system.
        #[derive(PartialEq, Eq, Clone)]
        pub struct Package {
            /// The name of the package.
            pub name: String,

            /// The version of the package.
            pub version: String,

            /// The current status of the package (e.g., see corresponding enum).
            pub status: PackageStatus,
        }

        impl Display for Package {
            fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
                write!(formatter, "{} => {}", self.name, self.version)
            }
        }

        /// Creates a default `Package` instance.
        ///
        /// This function initializes a `Package` with default values for its fields.
        /// It can be used when a default or placeholder instance of `Package` is required.
        ///
        /// # Returns
        ///
        /// A `Package` instance with default values:
        /// * name as an empty string,
        /// * version as an empty string,
        /// * status set to `PackageStatus::NotFound`.
        pub fn default_package() -> Package {
            Package {
                name: String::new(),
                version: String::new(),
                status: PackageStatus::NotFound,
            }
        }

        /// Represents a repository that can hold any type of repository type. The repository type
        /// depends on the underlying operating system.
        pub struct Repository<T> {
            /// The effective repository
            pub repos: T,
        }

        /// Trait defining standard requests related to packages.
        pub trait Request {
            /// Asks for a package given its name and version, returning a `Package` object.
            ///
            /// # Arguments
            ///
            /// * `package` - A string slice that holds the name of the package.
            /// * `version` - A string slice that holds the version of the package.
            ///
            /// # Returns
            ///
            /// A Package object.
            ///
            fn ask_package(&self, package: &str, version: &str) -> Package;

            /// Asks for the changelog of a package. The aim of this command is the access of a standard
            /// way to the changelog's package. The standard way means the changelog content thanks to
            /// the packaging standard feature of the current system.
            ///
            /// # Arguments
            ///
            /// * `package` - The `Package` object for which the changelog is requested.
            ///
            /// # Returns
            ///
            /// The changelog content.
            ///
            fn ask_changelog_package(&self, package: Package) -> String;

            /// Reads the changelog local files of a package. As the opposite of `ask_changelog_package`
            /// this method is an alternative way to access to local changelogs. Thanks to this method,
            /// it's possible to access to local changelog files if the standard way give no data.
            ///
            /// # Arguments
            ///
            /// * `package` - The `Package` object for which the changelog files are to be read.
            ///
            /// # Returns
            ///
            /// The local changelog files content.
            ///
            fn read_changelog_files(&self, package: Package) -> String;
        }

        /// Displays a list of CVEs (Common Vulnerabilities and Exposures) for a given package.
        ///
        /// # Arguments
        /// * `cve_list` - A vector containing CVE entries.
        /// * `package` - The package for which the CVEs are being shown.
        ///
        /// # Examples
        ///
        /// The arguments are showing with the form like this (eg: with command `get-cve less`):
        /// ```shell
        /// [ less => 2.9+b1 ]
        /// CVE-2023-1234
        /// CVE-2024-2232
        /// CVE-2024-5664
        /// ```
        ///
        pub fn show_cve_list(cve_list: Vec<Cve>, package: Package) {
            if cve_list.is_empty() {
                println!("No cve for: {}", package);
            } else {
                section_level!(package);
                cve_list.iter().for_each(print_cve);
            }
        }

        /// Print the cve
        ///
        /// # Arguments
        ///
        /// * `cve`- The cve to display
        ///
        pub fn print_cve(cve: &Cve) {
            println!(" {}", cve);
        }

        /// Filters a list of CVEs based on an optional filter string.
        ///
        /// # Arguments
        ///
        /// * `cve_list` - A vector of `Cve` objects to be filtered.
        ///   - Each `Cve` represents a Common Vulnerabilities and Exposures entry.
        ///
        /// * `filter` - An optional reference to a string to filter the `cve_list`.
        ///   - If `Some` filter is provided, it will be used for filtering the list of CVEs.
        ///   - If `None`, the original list will be returned with no filter applied.
        ///
        /// # Returns
        ///
        /// * A vector of filtered `Cve` objects based on the provided filter string or the original list if no filter is provided.
        ///
        /// # Examples
        ///
        /// ```shell
        /// get-cve less --filter 2023
        ///
        /// [less => 2.9+b1]
        /// CVE-2023-1234
        /// ```
        ///
        pub fn filtering_cve(cve_list: Vec<Cve>, filter: Option<&String>) -> Vec<Cve> {
            match filter {
                Some(filter) => filter_cve_list(cve_list, &filter.to_uppercase()),
                None => cve_list,
            }
        }

        fn filter_cve_list(cve_list: Vec<Cve>, filter: &str) -> Vec<Cve> {
            let filter_regex = Regex::new(filter).unwrap();
            cve_list
                .into_iter()
                .filter(|cve| filter_regex.is_match(&cve.reference))
                .collect()
        }

        /// Trait defining a contract for extracting CVEs from changelog content.
        ///
        pub trait Changelog {
            /// Extracts a list of CVEs from the given changelog content.
            ///
            /// # Arguments
            ///
            /// * `changelog_content` - A string slice that holds the content of the changelog.
            ///
            /// # Returns
            ///
            /// A vector of `Cve` structs that were found in the changelog content.
            fn cve_list(&self, changelog_content: &str) -> Vec<Cve>;
        }

        impl Changelog for Package {
            /// Implementation of the `cve_list` method for the `Package` struct.
            ///
            /// This method parses the provided changelog content and returns a list of CVEs.
            ///
            /// # Note
            ///
            /// The actual implementation uses a regex to search for CVE entries in the provided
            /// changelog content.
            fn cve_list(&self, changelog_content: &str) -> Vec<Cve> {
                const CVE_REGEX_PATTERN: &str = "CVE-[0-9]{4}-[0-9]+";
                let cve_regex = Regex::new(CVE_REGEX_PATTERN).unwrap();

                let mut cve_found: Vec<Cve> = extract_cves(&cve_regex, changelog_content);
                simplify_cve_list_content(&mut cve_found);

                cve_found
            }
        }

        fn extract_cves(cve_regex: &Regex, content: &str) -> Vec<Cve> {
            let mut cve_list = Vec::new();
            if cve_regex.is_match(&content.to_uppercase()) {
                for cve in cve_regex
                    .captures_iter(content)
                    .filter_map(|c| c.get(0).map(|m| m.as_str().to_string()))
                {
                    cve_list.push(Cve::new(cve));
                }
            }
            cve_list
        }

        /// Generates a changelog result based on the output of a changelog command. The alternative
        /// changelog files content are using in complement of the standard command uses to ensure to collect
        /// the maximum of cve data.
        ///
        /// # Arguments
        ///
        /// * `package` - A `Package` struct representing the package for which the changelog is searched.
        /// * `changelog_command` - An `Output` struct representing the output of the changelog command.
        /// * `local_changelog_content` - A `String` that represents the local changelog files content to use to
        ///   with the standard changelog command access.
        ///
        /// # Returns
        ///
        /// Returns a `String` containing the changelog result if the command was successful, or an empty string otherwise.
        ///
        pub fn changelog_result(
            package: Package,
            changelog_command: Output,
            local_changelog_content: String,
        ) -> String {
            let is_success = changelog_command.status.success();
            if is_success {
                handle_success(
                    changelog_command.stdout,
                    package.name.as_str(),
                    &local_changelog_content,
                )
            } else {
                String::new()
            }
        }

        fn handle_success(stdout: Vec<u8>, package_name: &str, alternative: &str) -> String {
            handle_stdout(stdout, package_name).add(alternative)
        }

        fn handle_stdout(stdout: Vec<u8>, package_name: &str) -> String {
            String::from_utf8(stdout).unwrap_or_else(|_| {
                handle_output_error(package_name);
                String::new()
            })
        }

        fn handle_output_error(package_name: &str) {
            write_error_message_and_exit("Output error", Some(package_name));
        }

        /// Simplifies the content of a list of CVEs by sorting and removing duplicates.
        ///
        /// # Arguments
        ///
        /// * `cve_list` - A mutable reference to a vector of `Cve` objects to be simplified.
        ///   - This vector will be sorted in place and then deduplicated, removing any duplicate `Cve` entries.
        ///
        pub fn simplify_cve_list_content(cve_list: &mut Vec<Cve>) {
            cve_list.sort();
            cve_list.dedup();
        }
    }

    /// The `errors` module contains utilities for handling errors related to packages.
    ///
    pub mod errors {
        use crate::package::concepts::Package;
        use std::process::exit;

        /// Shows the standard error message and exit the current process with the system value `1` as error code.
        ///
        /// The standard error message is: `Missing argument. See help.`.
        #[macro_export]
        macro_rules! no_argument_and_exit {
            () => {
                write_error_message_and_exit("Missing argument. See help.", None);
            };
        }

        /// Stops the execution if the package is invalid.
        ///
        /// # Arguments
        /// * `package` - A reference to the `Package` to be validated.
        ///
        /// An invalid package is one where both name and version are empty.
        /// In such cases, an error message is written and the process exits.
        ///
        pub fn stop_if_invalid_package(package: &Package) {
            if package.name.is_empty() && package.version.is_empty() {
                write_error_message_and_exit("Unsupported OS", None);
            }
        }

        /// Writes an error message with an optional argument and exits the process with a status code of 1.
        ///
        /// # Arguments
        /// * `message` - The error message to be written.
        /// * `argument` - An optional argument to be included in the error message.
        ///
        pub fn write_error_message_and_exit(message: &str, argument: Option<&str>) {
            write_error_message(message, argument);
            exit(1);
        }

        /// Writes an error message to standard error with an optional argument. No exit value.
        ///
        /// # Arguments
        /// * `message` - The error message to be written.
        /// * `argument` - An optional argument to be included in the error message.
        ///
        pub fn write_error_message(message: &str, argument: Option<&str>) {
            let final_message = match argument {
                Some(a) => format!("{}: {}", message, a),
                None => message.to_string(),
            };

            eprintln!("{final_message}");
        }
    }
}

/// The `facilities` module provides utility functions for handling
/// temporary directories and processing command results.
pub mod facilities {
    use crate::package::errors::write_error_message_and_exit;
    use chrono::{Datelike, Days, Local};
    use csv::{Reader, ReaderBuilder};
    use enable_ansi_support::enable_ansi_support;
    use indicatif::{ProgressBar, ProgressStyle};
    use regex::Regex;
    use serde_json::Value;
    use std::fs::File;
    use std::ops::Add;
    use std::path::{Path, PathBuf};
    use std::process::Output;
    use std::string::FromUtf8Error;
    use std::{env, io};

    /// Shows a flow of values
    #[macro_export]
    macro_rules! flow {
        ($value:expr) => {
            flow!(',', $value)
        };

        ($sep:expr, $value:expr) => {
            $value.split($sep).for_each(|x| value!(x.trim()))
        };
    }

    /// Formats a header for presentation. The text is formatted in upper cases with a green foreground.
    ///
    /// # Argument
    ///
    /// * `text`- The header text
    ///
    /// # Return
    ///
    /// A formatted String for this header.
    #[macro_export]
    macro_rules! header {
        ($value:expr) => {
            section!($value.to_string().to_ascii_uppercase()).fg(Color::Green)
        };
    }

    /// Shows a section with a level for section positioning. If one value is given, this value will
    /// be considering as the level 0.
    ///
    #[macro_export]
    macro_rules! section_level {
        ($value:expr) => {
            section_level!(0, $value)
        };

        ($n:expr, $value:expr) => {{
            let w: usize = $n;
            println!("{:>w$} {}", "", section!($value))
        }};
    }

    /// Formats a section for presentation.
    ///
    /// # Arguments
    ///
    /// * `title`- Title's section
    /// * `fg`- Text's colour. If `None` uses the default colour.
    /// * `bg`- Text background's colour. If `None` uses the default colour.
    ///
    /// # Returns
    ///
    /// A formatted String with foreground and background colours.
    #[macro_export]
    macro_rules! section {
        ($value:expr) => {{
            use termint::enums::Modifier;
            use termint::widgets::ToSpan;

            format!("[ {} ]", $value.to_string().first_uppercase())
                .as_str()
                .modifier(Modifier::BOLD)
        }};

        ($value:expr, $fg:expr) => {
            section!($value).fg($fg)
        };

        ($value:expr, $fg:expr, $bg:expr) => {
            section!($value, $fg).bg($bg)
        };
    }

    /// Show a label and value with a standard formatted way.
    ///
    /// # Arguments
    ///
    /// * `label` - optional label to add to the output
    /// * `value` - value to show on the output. The argument's name is using to build an automatic label
    ///
    #[macro_export]
    macro_rules! stamp {
        ($value:expr) => {{
            let values = stringify!($value).split(".").collect::<Vec<&str>>();
            if values.len() == 2 {
                println!(
                    "{:>6} {}: {}",
                    "-",
                    values[1]
                        .to_string()
                        .wording()
                        .replace("_", " ")
                        .first_uppercase(),
                    $value
                );
            } else {
                stamp!($value, $value);
            }
        }};

        ($label:expr, $value:expr) => {
            println!(
                "{:>6} {}: {}",
                "-",
                $label.to_string().first_uppercase(),
                $value
            )
        };
    }

    /// Shows the formatted value with a previous space of 6 positions
    ///
    /// # Argument
    /// * `value` - The value to show
    #[macro_export]
    macro_rules! value {
        ($value:expr) => {
            println!("{:>6} {}", "-", $value)
        };
    }

    /// Prints a slice of `Value` items, cleaning each value and separating them by commas.
    ///
    /// # Argument
    ///
    /// * `values` - A reference to a slice of `Value` objects that will be printed.
    ///
    pub fn print_values(values: &[Value]) {
        values.iter().for_each(|value| {
            match !value.is_object() {
                true => println!("{:>7} {}", "-", String::cleaning(value.to_string())),
                false => {
                    let map_value = value.as_object().unwrap();
                    map_value.iter().for_each(|(key, value)| {
                        println!("{:>6} {}:", "-", key.wording());
                        print_values(std::slice::from_ref(value));
                    });
                }
            };
        })
    }

    /// Returns the current date as a formatted string.
    ///
    /// # Examples
    /// ```
    /// use fenir::facilities::get_current_date;
    ///
    /// let current_date = get_current_date();
    /// println!("Today's date is: {}", current_date); // Output: "2023-10-05" (value may vary based on the current date)
    /// ```
    ///
    /// # Returns
    /// A `String` containing the current date in the format "YYYY-MM-DD".
    ///
    /// # Dependencies
    /// - `chrono`: This function uses the `chrono` crate for date and time operations.
    ///
    /// # Panics
    /// This function should not panic under normal circumstances.
    pub fn get_current_date() -> String {
        let local_date = Local::now();
        format!(
            "{}-{:02}-{:02}",
            local_date.year(),
            local_date.month(),
            local_date.day()
        )
    }

    /// Constructs a date range string from the provided arguments.
    ///
    /// This function extracts two dates from the `args` vector based on the
    /// index provided by `option_new_date`, and returns them concatenated
    /// with a semicolon (`;`) delimiter.
    ///
    /// # Arguments
    ///
    /// * `option_new_date` - An optional index pointing to the position
    ///   in `args` where the dates should be extracted.
    /// * `args` - A vector of strings from which the dates are to be extracted.
    ///
    /// # Returns
    ///
    /// A `String` containing the concatenated date range, or an empty string
    /// if the dates aren't found.
    ///
    /// # Examples
    ///
    /// ```
    /// use fenir::facilities::build_dates_range;
    ///
    /// let dates = build_dates_range(Some(0), &["".to_string(), "2023-01-01".to_string(), "2023-12-31".to_string()]);
    /// assert_eq!(dates, "2023-01-01;2023-12-31");
    /// ```
    pub fn build_dates_range(option_new_date: Option<usize>, args: &[String]) -> String {
        let mut dates = String::new();
        let regex = Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();
        if let Some(date_first) = args.get(option_new_date.unwrap() + 1) {
            if regex.is_match(date_first.as_str()) {
                dates = dates.add(date_first);
            } else {
                dates = create_default_date();
            }
        } else {
            dates = create_default_date();
        }

        if let Some(date_last) = args.get(option_new_date.unwrap() + 2) {
            if regex.is_match(date_last.as_str()) {
                dates = dates.add(";").add(date_last);
            } else {
                dates = create_next_date(dates);
            }
        } else {
            dates = create_next_date(dates);
        }

        dates
    }

    fn create_next_date(dates: String) -> String {
        let date_next = Local::now();
        let mut date_result = String::new();
        let result = date_next.checked_add_days(Days::new(1));
        if let Some(date) = result {
            date_result = dates
                .add(";")
                .add(date.format("%Y-%m-%d").to_string().as_str());
        }

        date_result
    }

    fn create_default_date() -> String {
        let date_current = Local::now();
        date_current.format("%Y-%m-%d").to_string()
    }

    /// Restores the current directory to its previous state and removes the specified temporary directory.
    ///
    /// # Arguments
    /// * `current_dir` - A result containing the path to the current directory.
    /// * `temp_dir_name` - The name of the temporary directory to be removed.
    ///
    /// This function sets the current directory to the one provided in `current_dir`,
    /// and then removes the temporary directory specified by `temp_dir_name`
    ///
    pub fn restore_current_dir_and_remove_temp_dir(
        current_dir: io::Result<PathBuf>,
        temp_dir_name: &str,
    ) {
        env::set_current_dir(current_dir.unwrap()).expect(
            "Can't restore initial \
                directory",
        );
        let _ = std::fs::remove_dir_all(format!("/var/tmp/{}", temp_dir_name).as_str());
    }

    /// Displays the result of a command execution.
    ///
    /// # Arguments
    /// * `command_result` - An `Output` struct representing the result of a command execution.
    ///
    /// # Returns
    /// * `Result<String, FromUtf8Error>` - The output of the command as a `String` if successful,
    ///   or an error if the output cannot be converted from UTF-8.
    ///
    /// This function checks if the command was successful.
    /// If the command failed, it writes an error message and exits.
    /// If the output of the command cannot be converted to a string, it also writes an error message and exits.
    ///
    pub fn show_command_result(command_result: Output) -> Result<String, FromUtf8Error> {
        if !command_result.status.success() {
            write_error_message_and_exit("Package not found", None);
        }

        let command_output = String::from_utf8(command_result.stdout);
        if command_output.is_err() {
            write_error_message_and_exit("Error on output parsing", None);
        }
        command_output
    }

    /// Trait for cleaning string content. Used for remove the `"`, `FIELD_SEPARATOR_CHAR` characters
    /// from value string.
    pub trait Cleaning {
        fn cleaning(value: String) -> String;
    }

    impl Cleaning for String {
        fn cleaning(value: String) -> String {
            let cleaning_char = ['"', FIELD_SEPARATOR_CHAR];

            let mut final_result = value.clone();

            if value.starts_with(cleaning_char) {
                final_result.remove(0);
            }

            if value.ends_with(cleaning_char) {
                final_result.remove(final_result.len() - 1);
            }

            final_result.replace("\\n", "\n")
        }
    }

    /// This trait allows to split a string to words. The words are identifying with the first char as uppercase.
    ///
    /// # Example
    ///
    /// ```rust
    /// use fenir::facilities::Wording;
    ///
    /// let result = "AStringForExample".to_string();
    ///
    /// assert_eq!("Astring for example".to_string(), result.wording())
    /// ```
    ///
    pub trait Wording {
        fn wording(&self) -> String;
    }

    impl Wording for String {
        fn wording(&self) -> String {
            let mut result = String::new();

            let mut chars = self.chars();
            let first = chars.nth(0);

            if let Some(c) = first {
                if c.is_ascii_lowercase() {
                    result.push(c.to_ascii_uppercase());
                } else {
                    result.push(c);
                }

                let mut previous = ' ';

                chars.for_each(|x| {
                    if x.is_ascii_lowercase() {
                        if previous.is_ascii_uppercase() {
                            result.push(' ');
                        }
                        result.push(x);
                        previous = x;
                    } else if x.is_ascii_uppercase() {
                        if previous.is_ascii_lowercase() {
                            result.push(' ');
                            previous = ' ';
                        }
                        result.push(x.to_ascii_lowercase());
                    } else {
                        result.push(x);
                        previous = x;
                    }
                });
            }

            result
        }
    }

    /// Categorizes the String content to verify if all char in the string is only in uppercases.
    pub trait Categorize {
        /// Verify if the string content is composing only of upper cases.
        ///
        /// # Arguments
        ///
        /// * `string` - The string for analysing.
        ///
        /// # Returns
        ///
        /// `true` if all string characters are uppercases, otherwise `false`.
        ///
        /// # Notes
        ///
        /// If the string is an empty string, will return `false`.
        fn only_uppercases(string: String) -> bool;
    }

    impl Categorize for String {
        fn only_uppercases(string: String) -> bool {
            let mut status = false;
            for chr in string.chars() {
                if chr == ' ' {
                    continue;
                }

                status = chr.is_ascii_uppercase();

                if !status {
                    break;
                }
            }

            status
        }
    }

    /// String standardization for data displaying. This trait prepares a string into the
    /// format awaiting by `hierarchical_show()` function.
    ///
    pub trait Standardize {
        /// Standardization is a process that allows to build a valid String format for hierarchical showing
        ///
        /// # Arguments
        ///
        /// * `self` - Self element on which the standardization will be applied.
        /// * `keywords`- Keywords list to take account during the standardization.
        ///
        /// # Return
        ///
        /// The new String with the standardization
        ///
        /// # See
        /// * `hierarchical_show()`.
        ///
        fn standardize(&self, keywords: Vec<&str>) -> String;
    }

    /// Char field separator for fields content long string from database
    const FIELD_SEPARATOR_CHAR: char = ':';

    /// String field separator for fields content long string from database
    pub const FIELD_SEPARATOR_STRING: &str = ":";

    pub const FIELD_SEPARATOR_STRING_LONG: &str = "::";

    impl Standardize for String {
        fn standardize(&self, keywords: Vec<&str>) -> String {
            if self.is_empty() {
                return String::new();
            }

            let elements = self.split(FIELD_SEPARATOR_CHAR).collect::<Vec<&str>>();
            let ref_value = 2;
            let mut counter = 0;
            let mut result = Vec::<String>::new();

            elements.iter().for_each(|s| {
                if s.is_empty() {
                    if counter != ref_value {
                        counter += 1;
                        result.push(FIELD_SEPARATOR_STRING.to_string());
                    } else {
                        counter = 0;
                    }
                } else {
                    if result.last().is_some() && result.last().unwrap() != FIELD_SEPARATOR_STRING {
                        result.push(FIELD_SEPARATOR_STRING.to_string());
                    }
                    if keywords.contains(s) {
                        result.push(s.to_string().to_uppercase());
                    } else if String::only_uppercases(s.to_string()) {
                        result.push(s.to_string().to_lowercase());
                    } else {
                        result.push(s.to_string());
                    }

                    counter = 0;
                }
            });

            begin_complement(&mut result);

            end_complement(&mut result);

            String::from_iter(result)
        }
    }

    fn begin_complement(result: &mut Vec<String>) {
        result[0..2]
            .iter_mut()
            .filter(|x| *x != FIELD_SEPARATOR_STRING)
            .for_each(|x| x.insert(0, FIELD_SEPARATOR_STRING.parse().unwrap()));
    }

    fn end_complement(result: &mut Vec<String>) {
        let length = result.len();
        result[length - 2..length]
            .iter_mut()
            .filter(|x| *x != FIELD_SEPARATOR_STRING)
            .for_each(|x| x.push(FIELD_SEPARATOR_STRING_LONG.parse().unwrap()));
    }

    /// Transform the list of keywords tho a String value with some specifics separators.
    /// With this trait, all keywords will be separated with specific separators.
    ///
    pub trait Transform {
        fn transform(&self, keywords: Vec<&str>) -> String;
    }

    /// Transform the string value to another string that replace all separator `::` with `-` and end
    /// of subline with the `\n`.
    impl Transform for String {
        fn transform(&self, keywords: Vec<&str>) -> String {
            let mut result = String::new();
            let tmp = format!("{}{}", FIELD_SEPARATOR_STRING, FIELD_SEPARATOR_STRING);
            let mark = tmp.as_str();

            let mut previous_key = "";
            keywords.iter().for_each(|&keyword| {
                let regex = Regex::new(keyword.to_string().as_str())
                    .unwrap_or_else(|_| panic!("Invalid regular expression pattern: {}", keyword));
                regex
                    .split(self)
                    .filter(|&sentence| !sentence.is_empty())
                    .for_each(|sentence| {
                        if sentence == mark {
                            result.push_str(mark);
                            result.push_str(keyword);
                            previous_key = keyword;
                        } else if sentence.chars().nth(0).unwrap() == FIELD_SEPARATOR_CHAR {
                            if previous_key.is_empty() {
                                result.push_str(mark);
                                result.push_str(keyword);
                            }
                            result.push_str(sentence);
                        } else {
                            result = result.replace(keyword, "");
                            result.push_str(mark);
                            result.push_str(keyword);
                            result.push(FIELD_SEPARATOR_CHAR);

                            if !sentence.contains(previous_key) || previous_key.is_empty() {
                                result.push_str(sentence);
                            }

                            previous_key = keyword;
                        }
                    });
            });

            if !result.ends_with(mark) && result.ends_with(FIELD_SEPARATOR_STRING) {
                result.push(FIELD_SEPARATOR_CHAR);
            }

            result
        }
    }

    /// Reduce a string to the given size. If the string length is > to the size value, the end of the
    /// string is replaced by the `...`.
    ///
    /// # Example
    ///
    /// ```rust
    /// use fenir::facilities::Reduce;
    ///
    /// let original = String::from("This is an example string");
    /// let result = original.reduce(16);
    ///
    /// assert_eq!(String::from("This is an ex..."), result);
    /// ```
    pub trait Reduce {
        /// Reduce the string to the given size.
        ///
        /// # Argument
        ///
        /// * `size` - The size of the new string
        fn reduce(&self, size: usize) -> String;
    }

    impl Reduce for String {
        fn reduce(&self, size: usize) -> String {
            if self.is_empty()
                || size == 0
                || size > self.len()
                || self == Value::Null.to_string().as_str()
            {
                self.clone()
            } else if size <= "...".len() {
                String::from("...")
            } else {
                let reduced =
                    self.escape_default().to_string()[0..(size - "...".len())].to_string();
                format!("{reduced}...")
            }
        }
    }

    /// Configures and returns a CSV reader with the specific settings.
    ///
    /// This function sets up a CSV reader with custom options such as delimiter,
    /// headers, and flexible end-of-line handling.
    ///
    /// # Arguments
    /// * `csv_path`- Path to the csv file.
    ///
    /// # Settings
    ///
    /// * `delimiter` - A `u8` byte set on `,` separator.
    /// * `has_headers`- A bool that specifies the CSV contains some header, set to `true`.
    /// * `flexible` - A `bool` that specifies whether to handle flexible end-of-line characters, set to `true`.
    ///
    /// # Returns
    ///
    /// * `csv::Reader<File>` - A `csv::Reader` configured based on the given settings.
    pub fn configure_csv_reader(csv_path: &Path) -> csv::Result<Reader<File>> {
        ReaderBuilder::new()
            .delimiter(b',')
            .flexible(true)
            .has_headers(true)
            .from_path(csv_path)
    }

    /// Shows the element list as a hierarchical design.
    ///
    /// # Arguments
    /// * `section` - The section name for this hierarchy.
    /// * `elements` - List of elements separated by the ':' separator.
    ///
    pub fn hierarchical_show(section: &str, elements: String) {
        if elements.is_empty() {
            return;
        }

        println!();
        let mut width: i32 = 0;

        let str_cleaning = String::cleaning(elements);

        section_level!(2, section);
        if !str_cleaning.contains(FIELD_SEPARATOR_STRING) {
            let w = (width + 7) as usize;
            println!("{:>w$} {}\n", "-", str_cleaning.trim());
            return;
        }

        let parts: Vec<&str> = str_cleaning.split(FIELD_SEPARATOR_STRING).collect();
        let ref_section = parts.get(1).unwrap_or(&"");

        section_show(ref_section, 0);

        let mut old_value = vec![];
        let mut last_section = ref_section;

        parts.iter().for_each(|part| {
            if !part.is_empty() && last_section != part {
                if String::only_uppercases(part.to_string()) {
                    last_section = part;
                    if last_section == ref_section {
                        width = -1;
                    }
                    width += 1;
                    section_show(part, width as usize);
                    old_value.clear();
                } else if !part.is_empty() && !old_value.contains(part) {
                    let w = (width + 7) as usize;
                    println!("{:>w$} {}", "-", part.trim());
                    old_value.push(*part);
                }
            }
        });
    }

    fn section_show(value: &str, width: usize) {
        let lower = String::from(value).to_ascii_lowercase();
        let wording = lower.wording();
        let words: Vec<&str> = wording.as_str().split(' ').collect();
        match words.len() {
            1..3 => {
                if !value.is_empty() {
                    let w = width + 3;
                    section_level!(w, value);
                }
            }
            _ => {
                if !value.is_empty() {
                    let w = width + 7;
                    println!("{:>w$} {}", "-", value.trim());
                }
            }
        };
    }

    /// Parse the current string for returning a string with the first character in uppercase.
    pub trait Uppercase {
        /// Transform the first character of a String to an uppercase
        ///
        /// # Returns
        /// The new string with the first character in uppercase
        fn first_uppercase(&self) -> String;
    }

    impl Uppercase for String {
        fn first_uppercase(&self) -> String {
            let c = self.chars().nth(0).unwrap();
            format!("{}{}", c.to_ascii_uppercase(), &self[1..])
        }
    }

    /// Configure the terminal for insure the ansi support colours
    /// for all platforms.
    pub fn configure_terminal() {
        let _ = enable_ansi_support();
    }

    /// Progress bar for text console.
    pub struct ProgressText {
        progress: ProgressBar,
    }

    impl ProgressText {
        /// Create a new occurrence of the ProgressText.
        ///
        /// # Arguments
        /// * `current` - Current value of the progress bar text.
        /// * `max`- Max value of the progress bar text.
        /// * `message`- Complement message adding at the end of the progress bar text.
        pub fn new(current: usize, max: usize, message: String) -> ProgressText {
            let progress = ProgressBar::new(max as u64)
                .with_message(message)
                .with_position(current as u64);
            progress.set_style(
                ProgressStyle::default_bar()
                    .template(
                        "[{elapsed_precise}] {bar:40.cyan/blue} {pos}/{len} records for '{msg}'",
                    )
                    .unwrap(),
            );

            Self { progress }
        }

        /// Increment the value of the progress bar and show the progression.
        ///
        /// # Note
        ///
        /// If the value of the progress bar is reach to the max value, this progress bar is considering as done.
        pub fn progress(&mut self) {
            if self.progress.position() == self.progress.length().unwrap() {
                self.progress.finish();
            } else {
                self.progress.inc(1);
            }
        }

        /// # Return
        /// The current value of the progress bar.
        pub fn value(&self) -> usize {
            self.progress.position() as usize
        }

        /// # Return
        /// The max value of the progress bar
        pub fn max(&self) -> usize {
            self.progress.length().unwrap() as usize
        }

        /// Status of the progress bar.
        ///
        /// # Return
        /// `true` if the progress bar is done. That means if the progress bar is done, some internal values
        /// will be unavailable (like message).
        pub fn is_done(&self) -> bool {
            self.progress.is_finished()
        }
    }
}

/// Several features for specific Os implementation. Provide several methods that can be used
/// for Os support implementations.
pub mod os {
    use std::path::{Path, PathBuf};
    use std::{env, fs};

    /// The `OSFamily` enum represents different families of operating systems.
    ///
    /// This enum provides several variants:
    /// - `Debian`: Represents Debian-based operating systems.
    /// - `macOS`: Represents the macOS operating systems.
    /// - `RedHat`: Represents RedHat-based operating systems.
    /// - `Unsupported`: Represents unsupported or unrecognized operating systems.
    /// - `Windows`: Represents the Windows operating systems.
    ///
    #[derive(PartialEq, Eq)]
    pub enum OSFamily {
        /// Represents Debian-based operating systems.
        Debian,

        /// Represents Macos-based operating systems.
        MacOS,

        /// Represents RedHat-based operating systems.
        RedHat,

        /// Represents unsupported or unrecognized operating systems.
        Unsupported,

        ///Represents the Windows-based operating systems.
        Windows,
    }

    // Constants for file paths
    const DEBIAN_PATH: &str = "/usr/bin/apt-get";
    const MACOS_PATH: &str = "/usr/bin/sw_vers";
    const REDHAT_PATH: &str = "/usr/bin/rpm";
    const WINDOWS_PATH: &str = "c:\\";

    /// Control if the current Os is included into the supported Os.
    pub struct SupportedOs;
    impl SupportedOs {
        /// Detects the operating system by checking for the existence of certain files.
        ///
        /// # Returns
        ///
        /// * `OSFamily::Debian` - if the system has `/usr/bin/apt-get`.
        /// * `OSFamily::macOS` - if the system has `/usr/bin/sw_vers`.
        /// * `OSFamily::RedHat` - if the system has `/usr/bin/rpm`.
        /// * `OSFamily::Windows` - if the system has `c:\\`.
        /// * `OSFamily::Unsupported` - if none of those files are found.
        pub fn supported_os() -> OSFamily {
            Debian::detect_os()
        }
    }

    /// Detect the current os family.
    trait OsDetector {
        /// Detects the current OSFamily.
        ///
        /// # Returns
        ///
        /// A value of type of `OSFamily`.
        fn detect_os() -> OSFamily;
    }

    /// Debian Os detector
    struct Debian;
    impl OsDetector for Debian {
        fn detect_os() -> OSFamily {
            if file_exists(DEBIAN_PATH) {
                OSFamily::Debian
            } else {
                Redhat::detect_os()
            }
        }
    }

    /// Redhat Os detector
    struct Redhat;
    impl OsDetector for Redhat {
        fn detect_os() -> OSFamily {
            if file_exists(REDHAT_PATH) {
                OSFamily::RedHat
            } else {
                MacOS::detect_os()
            }
        }
    }

    /// MacOs detector
    struct MacOS;
    impl OsDetector for MacOS {
        fn detect_os() -> OSFamily {
            if file_exists(MACOS_PATH) {
                OSFamily::MacOS
            } else {
                Windows::detect_os()
            }
        }
    }

    /// Windows Os detector.
    struct Windows;
    impl OsDetector for Windows {
        fn detect_os() -> OSFamily {
            if file_exists(WINDOWS_PATH) {
                OSFamily::Windows
            } else {
                OSFamily::Unsupported
            }
        }
    }

    /// Checks if a file exists at the given path.
    fn file_exists(path: &str) -> bool {
        Path::new(path).exists()
    }

    /// Find the tyr home's path directory according to current OS.
    ///
    /// # Returns
    ///
    /// The home path directory. If the OS is not supported, the home tyr path directory will be defined on the current dir.
    pub fn find_tyr_home_path() -> PathBuf {
        match SupportedOs::supported_os() {
            OSFamily::Windows => Path::new(Option::unwrap(env::var_os("HOMEDRIVE")).as_os_str())
                .join(Option::unwrap(env::var_os("HOMEPATH")).as_os_str())
                .join(".tyr"),
            OSFamily::Unsupported => Path::new(".").join(".tyr"),
            _ => Path::new(Option::unwrap(env::var_os("HOME")).as_os_str()).join(".tyr"),
        }
    }

    /// Create the tyr home path directory.
    ///
    /// # Arguments
    ///
    /// * `tyr_path` - the tyr path that will be used as tyr home path.
    ///
    /// # Notes
    ///
    /// If the tyr home path directory exists yet, it will not be recreated.
    pub fn create_tyr_home(tyr_path: &Path) {
        if !tyr_path.exists() {
            fs::create_dir(tyr_path).expect("Can't create tyr home path");
        }
    }

    /// Parse the raw id given as parameter and return the found id as u32
    ///
    /// # Arguments
    ///
    /// * `raw_id` - The raw cwe id of the form of `CWE-<num>` or `CAPEC-<num>`.
    ///
    /// # Results
    ///
    /// The id that is corresponding to the `<num>` part.
    pub fn parse_id(raw_id: &str, prefix: &str) -> Option<u32> {
        let parts: Vec<&str> = raw_id.split('-').collect();
        if parts.len() == 2 && parts[0].eq_ignore_ascii_case(prefix) {
            parts[1].parse().ok()
        } else {
            None
        }
    }
}

/// Module for database features (based on SQLite)
pub mod database {
    use crate::capec::CapecRecord;
    use crate::cwe::CweRecord;
    use crate::download::download_mitre_archive;
    use crate::facilities::{FIELD_SEPARATOR_STRING, Uppercase};
    use crate::mitre::MitreRecord;
    use crate::network::{fetch_json_response, parse_response};
    use crate::os::{create_tyr_home, find_tyr_home_path};
    use crate::package::errors::{write_error_message, write_error_message_and_exit};
    use crate::section;
    use regex::Regex;
    use rusqlite::{Connection, Rows, Statement, params};
    use serde_json::Value;
    use std::error::Error;
    use std::path::{Path, PathBuf};

    /// Mitre database name
    pub const MITRE_DB_NAME: &str = "mitre.db";

    /// Open the database connexion
    /// 
    /// # Example
    /// ```no_run
    /// match db_mitre!() {
    ///     Ok(connection) => println!("Connected with {:?}", connection),
    ///     Err(_) => eprintln!("Connection failed"),
    /// };
    /// ```
    #[macro_export]
    macro_rules! db_mitre {
        () => {
            Connection::open(db_mitre_path())
        };
    }

    /// The `MitreData` struct represents the necessary information to Mitre Data to used to.
    ///
    /// # Fields
    ///
    /// * `url` - A `String` that holds the URL for querying MITRE data to be used.
    /// * `sources` - A `Vector<String>` that denotes the list of path to download to be processed.
    #[derive(Clone)]
    pub struct MitreData {
        /// Data's name
        pub name: &'static str,

        /// The url to use for the mitre query
        pub url: &'static str,

        /// List of sources files
        pub files: Vec<&'static str>,
    }

    /// Defines a MitreData definition.
    ///
    pub trait MitreDefinition {
        /// Define the MitreData
        fn define() -> MitreData;
    }

    /// Define the tables definition for the Mitre data
    pub trait MitreDatabase {
        /// Gets the list of table definitions
        fn table_definitions(&self) -> Vec<(&'static str, &'static str)>;

        /// Gets the list of index definitions
        fn index_definitions(&self) -> Vec<(&'static str, &'static str)>;
    }

    /// Manage the database according to the database model defined with `MitreDatabase`.
    pub struct Database<T: MitreDatabase> {
        pub database: T,
    }

    impl<T: MitreDatabase> Database<T> {
        /// Checks if the database is valid or not.
        pub fn check_db(&self) {
            let conn = db_mitre!().unwrap();

            self.database
                .table_definitions()
                .iter()
                .for_each(|(table, _)| {
                    let query = format!("SELECT COUNT(*) FROM {}", table);
                    let result = conn.query_row(query.as_str(), [], |row| row.get::<usize, u32>(0));
                    if result.is_err() {
                        write_error_message_and_exit(
                            result.err().unwrap().to_string().as_str(),
                            None,
                        );
                    } else {
                        println!(
                            "Successfully queried MITRE table '{}' ({} records)",
                            table,
                            result.ok().unwrap()
                        );
                    }
                });
        }

        /// Create the table list.
        pub fn init_db(&self) {
            self.drop_tables();

            match db_mitre!() {
                Ok(connection) => {
                    self.database
                        .table_definitions()
                        .iter()
                        .for_each(|(name, definition)| {
                            match connection.execute(definition, params![]) {
                                Ok(_) => println!("Successfully created MITRE '{}'", name),
                                Err(e) => eprintln!("Error creating MITRE '{}' : {:?}", name, e),
                            };
                        });

                    self.drop_indexes();

                    self.database
                        .index_definitions()
                        .iter()
                        .for_each(|(idx, definition)| {
                            match connection.execute(definition, params![]) {
                                Ok(_) => println!("Successfully created MITRE index '{}'", idx),
                                Err(e) => eprintln!("Error creating MITRE index {}: {:?}", idx, e),
                            }
                        });
                }
                Err(e) => {
                    write_error_message_and_exit(
                        "Database connection error",
                        Some(e.to_string().as_str()),
                    );
                }
            };
        }

        fn drop_tables(&self) {
            let connection = db_mitre!().unwrap();
            self.database
                .table_definitions()
                .iter()
                .for_each(|(table, _)| {
                    let _ = connection
                        .execute(
                            format!("DROP TABLE IF EXISTS {}", table).as_str(),
                            params![],
                        )
                        .unwrap_or_else(|_| panic!("Error on dropping table: {}", table));
                });
        }

        fn drop_indexes(&self) {
            let connection = db_mitre!().unwrap();
            self.database
                .index_definitions()
                .iter()
                .for_each(|(idx, _)| {
                    let _ = connection
                        .execute(format!("DROP INDEX IF EXISTS {}", idx).as_str(), params![])
                        .unwrap_or_else(|_| panic!("Error on index dropping: {}", idx));
                });
        }
    }

    /// Executes a given query and processes the response.
    ///
    /// This function takes a `Result` containing a `String` query or an error message.
    /// It unwraps the query string, fetches the response from the URL specified by the query,
    /// and then parses this response into a `Value`.
    ///
    /// # Arguments
    ///
    /// * `query` - A `Result` wrapping a `String` query or an error message.
    ///
    /// # Returns
    ///
    /// * A `Value` obtained from parsing the response. If the response fetching or parsing
    ///   fails, it returns a default `Value`.
    ///
    /// # Panics
    ///
    /// This function will panic if `query` is an `Err` variant.
    ///
    /// # Example
    ///
    /// ```rust
    /// use fenir::database::execute_query;
    ///
    /// let query = Ok(String::from("http://example.com/api"));
    /// let value = execute_query(query);
    /// ```
    pub fn execute_query(query: Result<String, &str>) -> Value {
        let query_str = query.unwrap();
        let response = fetch_json_response(&query_str);

        parse_response(response)
    }

    /// New type for injector function that will be used for injecting data into the local
    /// SQLite database.
    type InjectorFunction = fn(&Path) -> Result<(), Box<dyn Error>>;

    /// Refresh the Mitre data that will be injected into the local database.
    ///
    /// # Arguments
    ///
    /// * `url` - The url to used to,
    /// * `file`- The file to download to.
    /// * `injector`- The method used for injecting the csv into the local database.
    ///
    /// # Results
    ///
    /// The final result of these operations.
    pub fn refresh_data_mitre_into_database(url: String, file: String, injector: InjectorFunction) {
        // Download and extract the archive
        let env_path = find_tyr_home_path();
        create_tyr_home(&env_path);
        let source_file = match download_mitre_archive(url, file.clone(), &env_path) {
            Err(e) => {
                write_error_message_and_exit("Error during download", Some(e.to_string().as_str()));
                String::new()
            }
            Ok(file) => file.clone(),
        };

        if !source_file.is_empty() {
            println!(
                "Source file downloaded successfully: {}",
                source_file.clone()
            );
        }

        match injector(&env_path.clone().join(source_file.clone())) {
            Err(e) => {
                write_error_message(
                    "Error during archive injection",
                    Some(e.to_string().as_str()),
                );
            }
            _ => {
                println!("Operation completed successfully: {}\n", file.clone());
            }
        }

        let _ = std::fs::remove_file(env_path.join(file.clone()));
        let _ = std::fs::remove_file(env_path.join(source_file.clone()));
    }

    /// find the cwe by its id.
    ///
    /// # Arguments
    ///
    /// * `cwe_id`- CWE's id
    ///
    /// # Returns
    ///
    /// A `CweRecord` if CWE found or `None`.
    ///
    pub fn find_cwe_by_id(cwe_id: u32) -> Option<CweRecord> {
        let connection = db_mitre!().unwrap();
        let mut statement = connection
            .prepare("SELECT * FROM cwe WHERE id= :id_cwe")
            .ok()?;
        let mut rows = statement.query(&[(":id_cwe", &cwe_id)]).ok()?;
        let row = rows.next().ok()?;
        if row.is_some() {
            Some(CweRecord {
                id: row?.get(0).unwrap(),
                name: row?.get(1).unwrap(),
                description: row?.get(2).unwrap(),
                extended: row?.get(3).unwrap_or("".to_string()),
                consequences: row?.get(4).unwrap(),
                detections: row?.get(5).unwrap_or("".to_string()),
                mitigations: row?.get(6).unwrap_or("".to_string()),
                attacks: row?.get(7).unwrap_or("".to_string()),
            })
        } else {
            None
        }
    }

    /// find the capec by its id.
    ///
    /// # Arguments
    ///
    /// * `capec_id`- Capec's id
    ///
    /// # Returns
    ///
    /// A `CapecRecord` if CAPEC found or `None`.
    ///
    pub fn find_capec_by_id(capec_id: u32) -> Option<CapecRecord> {
        let connection = db_mitre!().unwrap();
        let mut statement = connection
            .prepare("SELECT * FROM capec WHERE id= :id_capec")
            .ok()?;
        let mut rows = statement.query(&[(":id_capec", &capec_id)]).ok()?;
        let row = rows.next().ok()?;
        if row.is_some() {
            Some(CapecRecord {
                id: row?.get(0).unwrap(),
                name: row?.get(1).unwrap(),
                abstraction: row?.get(2).unwrap(),
                status: row?.get(3).unwrap(),
                description: row?.get(4).unwrap(),
                alternates: row?.get(5).unwrap_or("".to_string()),
                likelihood: row?.get(6).unwrap_or("".to_string()),
                severity: row?.get(7).unwrap_or("".to_string()),
                attacks: row?.get(8).unwrap_or("".to_string()),
                flow: row?.get(9).unwrap_or("".to_string()),
                prerequisites: row?.get(10).unwrap_or("".to_string()),
                skills: row?.get(11).unwrap_or("".to_string()),
                resources: row?.get(12).unwrap_or("".to_string()),
                indicators: row?.get(13).unwrap_or("".to_string()),
                consequences: row?.get(14).unwrap_or("".to_string()),
                mitigations: row?.get(15).unwrap_or("".to_string()),
                instances: row?.get(16).unwrap_or("".to_string()),
                weaknesses: row?.get(17).unwrap_or("".to_string()),
                taxonomy: row?.get(18).unwrap_or("".to_string()),
            })
        } else {
            None
        }
    }

    /// Analyse a string criteria and split each element by separating the words criteria from the operators.
    ///
    /// # Arguments
    ///
    /// * `criteria` - Criteria string for analysis
    ///
    /// # Results
    ///
    /// A couple of values where the first argument is the list of operators and the second the list of words of the criteria
    ///
    pub fn criteria_analysis(criteria: String) -> Option<(Vec<String>, Vec<String>)> {
        if criteria.is_empty() {
            None
        } else {
            let regex = Regex::new(r"\b(?:and|not|or)\b");
            let result = regex
                .clone()
                .unwrap()
                .captures_iter(&criteria)
                .collect::<Vec<_>>();
            let mut operators = Vec::<String>::new();
            result.iter().for_each(|cap| {
                operators.push(cap.get(0).unwrap().as_str().to_string());
            });

            let mut crit = criteria.clone();
            ["not ", "and ", "or "].iter().for_each(|&o| {
                crit = crit.replace(o, "^");
            });

            let words = words_collector(criteria);
            Some((words, operators))
        }
    }
    
    fn words_collector(criteria: String) -> Vec<String> {
        
        let mut crit = criteria.clone();
        ["not ", "and ", "or "].iter().for_each(|&o| {
            crit = crit.replace(o, "^");
        });

        let mut words = Vec::<String>::new();
        let mut others = Vec::<char>::new();
        let mut keep_space = false;
        let chars = crit.chars();
        chars.for_each(|c| {
            if c != '\'' && c == '^' {
                if !others.is_empty() {
                    words.push(others.iter().collect());
                    others.clear();
                }
                words.push(String::new());
            } else if keep_space || c != ' ' {
                others.push(c);
            } else {
                keep_space = !keep_space;
            }
        });

        if !others.is_empty() {
            words.push(others.iter().collect());
        }
        
        words
    }

    /// Split the arguments list to `domain` and `criteria`. `domain` is corresponding to
    /// the name of field into the concerning table's database.
    ///
    /// # Arguments
    ///
    ///  * `arguments` - List of arguments that's composing the query
    ///
    /// # Results
    ///
    /// A couple of values with the domain for the first field, and left of criteria for the
    /// second field.
    pub fn find_domain_and_criteria(arguments: &[String]) -> Option<(String, String)> {
        let string_args = arguments.iter().last().unwrap();
        let mut pattern = "=";
        let is_sep = match string_args.find(pattern) {
            Some(s) => Some(s),
            None => {
                pattern = "not";
                string_args.find(pattern)
            }
        };

        if let Some(pos_sep) = is_sep {
            let domain = String::from(string_args[0..pos_sep].trim());
            let criteria = match pattern {
                "not" => format!("not {}", string_args[pos_sep + pattern.len()..].trim()),
                _ => String::from(string_args[pos_sep + pattern.len()..].trim()),
            };

            match domain.is_empty() || criteria.is_empty() {
                true => None,
                false => Some((domain, criteria)),
            }
        } else {
            None
        }
    }

    /// Associate the list of arguments with the SQL query in construction
    ///
    /// # Arguments
    ///
    /// * `words` - list of arguments words
    /// * `statement`- statement SQL in construction
    ///
    /// # Results
    ///
    /// The statement completed by the criteria binding
    ///
    pub fn bind_criteria<'a>(
        words: &[String],
        statement: Result<Statement<'a>, rusqlite::Error>,
    ) -> Statement<'a> {
        let mut counter = 1;
        let mut statement = statement.unwrap();
        let nb = words.len();
        for word in words.iter().take(nb) {
            if !word.trim().is_empty() {
                statement
                    .raw_bind_parameter(counter, format!("%{}%", word.to_lowercase().trim()))
                    .unwrap_or_else(|_| {
                        panic!(
                            "{}",
                            format!("Can't bind parameter: {}", word.to_lowercase()).trim()
                        )
                    });
                counter += 1;
            }
        }

        statement
    }

    /// Prepare the query model given as parameter with the elements of criteria
    ///
    /// # Arguments
    ///
    /// * `query_template`- Query model used to prepare the final query
    /// * `words`- list of words to use as criteria into the query template.
    /// * `operators`- list of operators.
    ///
    /// # Results
    ///
    /// The final query
    pub fn prepare_query(
        query_template: String,
        words: Vec<String>,
        operators: &[String],
    ) -> FinalQuery {
        let mut query = query_template.clone();
        let domain = query_template.rsplit_once(' ').unwrap().1;

        let mut count_like = 1;
        let mut count_op = 0;

        words.iter().for_each(|word| {
            if !word.trim().is_empty() {
                query.push_str(format!(" LIKE ?{}", count_like).as_str());
                count_like += 1;
            } else if count_op < operators.len() {
                let op = &operators[count_op];
                count_op += 1;
                let query_str = match op.as_str() {
                  "not" => format!(" {} ", op.trim()),
                  _ => format!(" {op} {domain} ")
                };
                
                query.push_str(query_str.as_str());
            }
        });
        
        (query, words)
    }

    /// Return the path of mitre database
    ///
    /// # Results
    ///
    /// Mitre database path
    pub fn db_mitre_path() -> PathBuf {
        let tyr_home = find_tyr_home_path();
        create_tyr_home(&tyr_home);
        tyr_home.join(MITRE_DB_NAME)
    }

    /// Record extractor from the search result
    pub type SearchResultExtractor<T> = fn(&mut Rows) -> Vec<T>;

    type FinalQuery = (String, Vec<String>);

    /// Search the list of words into the database.
    ///
    /// `<T>` is the type of record as the result of the extraction.
    ///
    /// # Arguments
    /// * `query_string` - SQL string query
    /// * `words` - list of words for this query
    /// * `extractor`- function use to extract the searching result
    ///
    /// # Result
    ///
    /// A list of records according to T type
    ///
    pub fn search<T>(final_query: FinalQuery, extractor: SearchResultExtractor<T>) -> Vec<T> {
        let connection = db_mitre!().unwrap();
        let statement = connection.prepare(final_query.0.as_str());
        let mut binding = bind_criteria(&final_query.1, statement);
        let mut rows = binding.raw_query();

        extractor(&mut rows)
    }

    /// Parse the string values to a list of unsigned 32 bits.
    /// The string must be formatted like this: `::<num>::<num>::...::`
    ///
    /// # Argument
    /// * `values` - raw string values to parse to
    ///
    /// # Result
    /// The list of unsigned 32 values.
    pub fn parse_id_to_u32(values: String) -> Vec<u32> {
        let mut id_list: Vec<u32> = values
            .split(FIELD_SEPARATOR_STRING)
            .map(|v| {
                if !v.is_empty() {
                    let chars = v.chars();
                    let length = chars.clone().count();
                    let mut counter: usize = 0;
                    chars.for_each(|c| {
                        if c.is_ascii_digit() {
                            counter += 1;
                        }
                    });

                    if counter == length {
                        v.parse::<u32>().unwrap()
                    } else {
                        0
                    }
                } else {
                    0
                }
            })
            .collect();

        id_list.sort();
        id_list.dedup();
        id_list.retain(|x| *x != 0);
        id_list
    }

    /// Finds the list of columns for the given table name
    ///
    /// # Argument
    ///
    /// * `table_name` - The table's name to explore.
    ///
    /// # Return
    ///
    /// The list of column's names for this table.
    pub fn find_columns(table_name: &str) -> Vec<String> {
        let db = db_mitre!().unwrap();
        let sql_select = format!("SELECT * FROM {table_name}");
        let stmt = db.prepare(sql_select.as_str()).unwrap();

        stmt.column_names()
            .iter()
            .map(|x| x.to_string())
            .collect::<Vec<String>>()
    }

    /// Search fonction type. The args ar the criteria used for the searching function implementation.
    type Searcher = fn(args: &[String]);

    /// Search the values into the list of columns.
    ///
    /// # Arguments
    ///
    /// * `args`- Arguments of the searching.
    /// * `columns`- The list of columns in which all arguments will be applied.
    pub fn searching(args: &[String], columns: &[String], searcher: Searcher) {
        let args_id = args.iter().position(|x| x == "search" || x == "s").unwrap();
        let criteria = &args[args_id + 1..];
        if criteria[0].contains(&"all".to_string()) {
            let args_left = criteria[0]["all".len()..].to_string();
            columns.iter().for_each(|x| {
                if *x != "id" {
                    println!("{}", section!(format!("Searching for domain: {x}")));
                    let args = format!("{} {}", x, &args_left);
                    searcher(&[args]);
                }
            });
        } else {
            searcher(args);
        }
    }

    /// Refresh the mitre database. the function takes a string that contains a list of csv files and the associated url.
    /// The method converts this string in an internal vector and create the query to download the CSV file from the
    /// associated url and inject these values into the local mitre database.
    ///
    /// # Arguments
    ///
    /// * `mitre_data` - MitreData description for the database
    /// * `injector` - the associated injector function that allows to store the downloaded data into the local database.
    ///
    pub fn refresh_mitre_database(mitre_data: MitreData, injector: InjectorFunction) {
        let csv_files = mitre_data.files;
        csv_files.iter().for_each(|&x| {
            refresh_data_mitre_into_database(mitre_data.url.to_string(), x.to_string(), injector);
        });
    }

    /// Find the mitre record according to the mitre's identification.
    ///
    /// # Argument
    /// * `id` - Mitre identification. This id is a simple id value without the `T` of this id.
    ///
    /// # Return
    ///
    /// The Mitre record found or None.
    ///
    /// # Example
    ///
    /// ```rust
    /// use fenir::database::find_mitre_by_id;
    /// use fenir::mitre::MitreRecord;
    ///
    /// let result: Option<MitreRecord> = find_mitre_by_id("1531");
    ///
    /// if result.is_none() {
    ///     eprintln!("Mitre record not found.");
    /// } else {
    ///     println!("Mitre record found");
    /// }
    /// ```
    pub fn find_mitre_by_id(id: &str) -> Option<MitreRecord> {
        if id.is_empty() {
            return None;
        }

        let conn = db_mitre!().unwrap();
        let query = format!("SELECT * FROM technique WHERE id = 'T{}'", id);
        let results = conn.prepare(query.as_str());
        if let Ok(mut results) = results {
            let value = results.query_row([], |row| {
                Ok(MitreRecord {
                    id: row.get(0).unwrap(),
                    name: row.get(1).unwrap(),
                    description: row.get(2).unwrap(),
                    url: row.get(3).unwrap(),
                    created: row.get(4).unwrap(),
                    modified: row.get(5).unwrap(),
                    domain: row.get(6).unwrap(),
                    version: row.get(7).unwrap(),
                    tactics: row.get(8).unwrap(),
                    platforms: row.get(9).unwrap(),
                    sub_techniques: row.get(10).unwrap_or("Unknown".to_string()),
                    contributors: row.get(11).unwrap_or("Unknown".to_string()),
                    support_remote: row.get(12).unwrap_or_default(),
                    impact_type: row.get(13).unwrap_or("Unknown".to_string()),
                    citations: row.get(14).unwrap(),
                    tactic_type: row.get(15).unwrap_or("Unknown".to_string()),
                    mtc_id: row.get(16).unwrap_or("Unknown".to_string()),
                })
            });
            value.ok()
        } else {
            None
        }
    }

    /// Return the `Value::Null` if the string argument is empty. Otherwise return the corresponding `Value`/
    ///
    /// # Argument
    ///
    /// * `final_result`- The string value to parse to `Value` type.
    ///
    /// # Return
    ///
    /// The corresponding `Value`.
    ///
    /// # Example
    ///
    /// ```rust
    /// use rusqlite::types::Value;
    /// use fenir::database::text_or_null;
    ///
    /// let result = text_or_null("".to_string());
    ///
    /// assert_eq!(Value::Null, result);
    ///
    /// let other = text_or_null("A string".to_string());
    ///
    /// assert_eq!(Value::Text("A string".to_string()), other);
    /// ```
    pub fn text_or_null(final_result: String) -> rusqlite::types::Value {
        if final_result.is_empty() {
            rusqlite::types::Value::Null
        } else {
            rusqlite::types::Value::Text(final_result)
        }
    }
}

/// Tools for download support
pub mod download {
    use std::error::Error;
    use std::fs::File;
    use std::io::{Read, Write};
    use std::path::Path;
    use ureq::Body;
    use ureq::http::Response;
    use zip::ZipArchive;

    /// Downloads a MITRE archive from the given query URL. If the source file is a ZIP file type,
    /// extracts the source file from the ZIP archive.
    ///
    /// This function performs the following steps:
    /// 1. Fetches the source file content from the `query` URL.
    /// 2. Saves the downloaded the file specified by `query.source_file`.
    /// 3. Extracts the required ZIP archive specified if the file is a ZIP type.
    ///
    /// # Arguments
    ///
    /// * `query` - An instance of `QueryMitre` struct containing the required URL,
    ///   and source file.
    /// * `env_path`- The tyr home path.
    ///
    /// # Returns
    ///
    /// This function returns a `Result` type:
    /// * `Ok(String)` - If the process was successful. Contains the source file to used to.
    /// * `Err(Box<dyn std::error::Error>)` - If any error occurred during downloading, saving, or extracting.
    ///
    /// # Errors
    ///
    /// The function will return an error in cases such as:
    /// * Network issues while downloading the source file.
    /// * Problems during the unzipping file if it's a ZIP archive.
    ///
    /// # Example
    ///
    /// ```rust
    /// use fenir::download::{download_mitre_archive};
    /// use fenir::os::find_tyr_home_path;
    /// use std::path::Path;
    ///
    /// if let Err(e) = download_mitre_archive("https://example.com".to_string(), "data.csv.zip".to_string(), &find_tyr_home_path()) {
    ///     eprintln!("Error: {}", e);
    /// }
    ///
    /// let tyr_home = find_tyr_home_path();
    /// std::fs::remove_file(tyr_home.join(Path::new("data.csv.zip")));
    /// ```
    pub fn download_mitre_archive(
        url: String,
        file: String,
        env_path: &Path,
    ) -> Result<String, Box<dyn Error>> {
        let full_url = format!("{}/{}", url, file);
        let response = fetch_url(full_url.as_str());

        save_downloaded_archive(response, file.as_str(), env_path)?;

        if file.ends_with(".zip") {
            let target_file = file.trim_end_matches(".zip");
            extract_zip_file(file.as_str(), target_file, env_path)?;
            Ok(target_file.to_string())
        } else {
            Ok(file)
        }
    }

    /// Fetches a CSV file from a given URL.
    ///
    /// This function sends a GET request to the specified URL and attempts to fetch the CSV file.
    /// It checks if the request was successful by verifying the HTTP status code.
    ///
    /// # Arguments
    ///
    /// * `url` - A string slice that holds the URL of the CSV file to be fetched.
    ///
    /// # Returns
    ///
    /// This function returns a `Result` containing a `Response` object on success, or a `Box<dyn Error>` on failure.
    ///
    /// # Errors
    ///
    /// This function will return an error if:
    ///
    /// * The request fails (e.g., due to network issues).
    /// * The server responds with a non-200 HTTP status code.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use fenir::download::fetch_url;
    ///
    /// let url = "https://www.google.com";
    /// let response = fetch_url(url);
    ///
    /// // Process the response...
    /// if response.is_err() {
    ///     eprintln!("Url is not responding: {url}");
    /// } else {
    ///     println!("Fetched response for: {url}");
    /// }
    /// ```
    ///
    /// # Dependencies
    ///
    /// This function relies on the `ureq` crate for HTTP requests.
    pub fn fetch_url(url: &str) -> Result<Response<Body>, Box<dyn Error>> {
        // Send GET request to the URL
        let response = ureq::get(url).call()?;

        // Ensure the request was successful
        if response.status() != 200 {
            return Err(format!("Failed to download archive: HTTP {}", response.status()).into());
        }

        Ok(response)
    }

    /// Saves a downloaded archive to a specified file.
    ///
    /// # Arguments
    ///
    /// * `response` - A `Result` wrapping the HTTP `Response` object if the request was successful,
    ///   or an error if the request failed.
    /// * `zip_file_name` - A string slice that holds the name of the file where the downloaded archive will be saved.
    /// * `env_path`- The tyr home path.
    ///
    /// # Returns
    ///
    /// This function returns a `Result`:
    ///
    /// * `Ok(())` if the file was successfully saved.
    /// * `Err(Box<dyn Error>)` if any error occurred during the process.
    /// * `env_path`- The tyr home path.
    ///
    /// # Errors
    ///
    /// This function will return an error if:
    ///
    /// * The file cannot be created.
    /// * Reading the response content fails.
    /// * Writing the content to the file fails.
    ///
    pub fn save_downloaded_archive(
        response: Result<Response<Body>, Box<dyn Error>>,
        zip_file_name: &str,
        env_path: &Path,
    ) -> Result<(), Box<dyn Error>> {
        let mut out = File::create(env_path.join(zip_file_name))?;
        let mut content = vec![];
        response?
            .into_body()
            .as_reader()
            .read_to_end(&mut content)?;
        out.write_all(&content)?;
        Ok(())
    }

    /// Extracts a specified CSV file from a ZIP file and saves it to the filesystem.
    ///
    /// # Arguments
    ///
    /// * `from_zip_file_name` - A string slice that holds the name of the ZIP file to be read.
    /// * `to_csv_file_name` - A string slice that holds the name of the CSV file inside the ZIP to be extracted and saved.
    /// * `destination_path`- The path where to store the extracted zip.
    ///
    /// # Returns
    ///
    /// This function returns a `Result` type. On success, it returns an empty tuple `()`. On failure, it returns an error wrapped in a `Box<dyn Error>`.
    ///
    /// # Example
    ///
    /// ```
    /// use fenir::download::extract_zip_file;
    /// use fenir::os::find_tyr_home_path;
    ///
    /// let result = extract_zip_file("data.zip", "data.csv", &find_tyr_home_path());
    /// if let Err(e) = result {
    ///     println!("Error extracting file: {}", e);
    /// }
    /// ```
    ///
    /// # Errors
    ///
    /// The function will return an error in the following cases:
    /// * If the ZIP file cannot be opened.
    /// * If the specified CSV file does not exist in the ZIP.
    /// * If the CSV file cannot be read or written to the filesystem.
    pub fn extract_zip_file(
        from_zip_file_name: &str,
        to_csv_file_name: &str,
        destination_path: &Path,
    ) -> Result<(), Box<dyn Error>> {
        // Extract the CSV file from the ZIP
        let file = File::open(destination_path.join(from_zip_file_name))?;
        let mut archive = ZipArchive::new(file)?;
        let mut csv_file = archive.by_name(to_csv_file_name)?;
        let mut csv_content = String::new();
        csv_file.read_to_string(&mut csv_content)?;
        // Save the CSV content to a file
        let mut extracted_csv = File::create(destination_path.join(to_csv_file_name))?;
        extracted_csv.write_all(csv_content.as_bytes())?;
        Ok(())
    }
}

/// Module with helper function for NVD REST network query.
pub mod query {
    use crate::cpe::NVD_CPE_LINK;
    use crate::facilities::get_current_date;
    use crate::query::QueryType::{ByCpeSearchWords, ByCveNew, ByCveUpdated};
    use crate::{NVD_CVE_LINK, URL_SPACE};

    /// `QueryType` is an enumeration representing the types of queries that can be made
    /// for Common Vulnerabilities and Exposures (CVE). It derives `Eq`, `PartialEq`, and `Clone`
    /// traits for equality comparisons and cloning capabilities.
    #[derive(Eq, PartialEq, Clone)]
    pub enum QueryType {
        /// Query by a specific CVE identifier.
        ByCve,

        /// Query by a CVE for a CPE name (string description)
        ByCveCpeName,

        /// Query for a known exploited CVE list
        ByCveExploited,

        /// Query to retrieve new CVEs.
        ByCveNew,

        /// Query by search strings
        ByCveSearchString,

        /// Query by search strings with strict mode
        ByCveSearchStrict,

        /// Query to retrieve updated CVEs.
        ByCveUpdated,

        /// Query by a Common Platform Enumeration (CPE) identifier.
        ByCpe,

        /// Query to perform CPE matching.
        ByCpeMatch,

        /// Query to perform CPE searching by considering the word arguments as a single criteria.
        ByCpeSearchStrict,

        /// Query to perform CPE searching according to a list of words.
        ByCpeSearchWords,

        /// Query about vulnerable CPE
        ByCpeVulnerable,

        /// Query by a Common Weakness Enumeration (CWE) identifier.
        ByCwe,

        /// Cve http link test
        LinkTest,
    }

    macro_rules! query_dates_for_new_cve {
        ($d1:expr) => {
            query_dates_for_new_cve!($d1, "")
        };

        ($d1:expr, $d2:expr) => {
            query_dates!("pub", $d1, $d2)
        };
    }

    macro_rules! query_dates_for_updated_cve {
        ($d1: expr) => {
            query_dates_for_updated_cve!($d1, "")
        };

        ($d1: expr, $d2:expr) => {
            query_dates!("lastMod", $d1, $d2)
        };
    }

    macro_rules! query_dates {
        ($prefix:expr, $d1:expr, $d2:expr) => {{
            let date1 = match $d1.to_string().is_empty() {
                true => get_current_date(),
                false => $d1.to_string(),
            };

            let date2 = match $d2.to_string().is_empty() {
                true => get_current_date(),
                false => $d2.to_string(),
            };

            format!(
                "{}StartDate={}T00:00:00.000&{}EndDate={}T00:00:00.000",
                $prefix, date1, $prefix, date2
            )
        }};
    }

    /// Generates a query string for CVE (Common Vulnerabilities and Exposures) based on the provided query date type
    /// and date values.
    ///
    /// # Arguments
    ///
    /// * `query_date` - An instance of `CveQueryType` enum specifying the type of date query (new CVEs or updated CVEs).
    /// * `value` - A string containing date values separated by a semicolon (`;`). The values represent start and end dates
    ///   respectively. If only one date is provided, it will be considered as both the start and end date.
    ///
    /// # Returns
    ///
    /// A `String` containing the constructed query with appropriate start and end dates.
    ///
    /// - For `CveNew`, it constructs `pubStartDate` and `pubEndDate` parameters.
    /// - For `CveUpdated`, it constructs `lastModStartDate` and `lastModEndDate` parameters.
    ///
    /// If a date is empty, the current date is used as a fallback.
    ///
    /// # Examples
    ///
    /// ```
    /// use fenir::query::{QueryType, create_query_dates};
    /// use fenir::facilities::get_current_date;
    ///
    /// let result = create_query_dates(QueryType::ByCveNew, "2023-01-01;2023-12-31");
    /// assert_eq!(result, "pubStartDate=2023-01-01T00:00:00.000&pubEndDate=2023-12-31T00:00:00.000");
    ///
    /// let result = create_query_dates(QueryType::ByCveUpdated, "2023-01-01;");
    /// let current_date = get_current_date();
    ///
    /// assert_eq!(result, format!("lastModStartDate=2023-01-01T00:00:00.000&lastModEndDate={}T00:00:00.000", current_date));
    /// ```
    pub fn create_query_dates(query_date: QueryType, value: &str) -> String {
        let dates: Vec<&str> = value.split(";").collect();
        match dates.len() {
            2 => match query_date {
                ByCveNew => {
                    query_dates_for_new_cve!(dates[0], dates[1])
                }

                ByCveUpdated => {
                    query_dates_for_updated_cve!(dates[0], dates[1])
                }
                _ => String::new(),
            },

            1 => match query_date {
                ByCveNew => {
                    query_dates_for_new_cve!(dates[0])
                }

                ByCveUpdated => {
                    query_dates_for_updated_cve!(dates[0])
                }

                _ => String::new(),
            },
            _ => String::new(),
        }
    }

    /// Builds a query URL based on the type of query and a URL argument. Thanks to the `query_type`
    /// argument, the details for full URL constructing is taking in charge automatically.
    ///
    /// # Arguments
    ///
    /// * `query_type` - A variant of the `CveQueryType` enum specifying the type of CVE query.
    /// * `url_argument` - A string slice that holds the argument to be passed in the URL query.
    ///
    /// # Returns
    ///
    /// If successful, returns `Ok` containing the constructed query URL as a `String`.
    /// Otherwise, returns an `Err` with a static string slice indicating the error.
    ///
    /// # Examples
    /// ```
    /// use fenir::NVD_CVE_LINK;
    /// use fenir::query::{QueryType, build_query};
    ///
    /// let query_url = build_query(QueryType::ByCve, "CVE-2021-3456").unwrap();
    /// assert_eq!(query_url, format!("{}?cveId=CVE-2021-3456", NVD_CVE_LINK));
    /// ```
    pub fn build_query(query_type: QueryType, url_argument: &str) -> Result<String, &'static str> {
        match query_type {
            QueryType::ByCve => Ok(format!(
                "{NVD_CVE_LINK}?cveId={}",
                url_argument.to_uppercase()
            )),

            QueryType::ByCveCpeName => Ok(format!(
                "{NVD_CVE_LINK}?virtualMatchString={}",
                url_argument
            )),

            QueryType::ByCveExploited => Ok(format!("{NVD_CVE_LINK}?hasKev")),

            ByCveNew | ByCveUpdated => Ok(format!(
                "{NVD_CVE_LINK}?{}",
                create_query_dates(query_type, url_argument)
            )),

            QueryType::ByCwe => Ok(format!(
                "{NVD_CVE_LINK}?cweId={}",
                url_argument.to_uppercase()
            )),

            QueryType::ByCpeVulnerable => {
                let query_str = build_query(QueryType::ByCveCpeName, url_argument)?;
                Ok(format!("{}&isVulnerable", query_str))
            }

            QueryType::ByCveSearchString => {
                Ok(format!("{NVD_CVE_LINK}?keywordSearch={}", url_argument))
            }

            QueryType::ByCveSearchStrict => {
                let query_str = build_query(QueryType::ByCveSearchString, url_argument)?;
                Ok(format!("{}&keywordExactMatch", query_str))
            }

            QueryType::ByCpe => Ok(format!("{NVD_CPE_LINK}?cpeName={}", url_argument)),

            QueryType::ByCpeMatch => Ok(format!(
                "{NVD_CPE_LINK}?cpeMatchString={}",
                url_argument.to_lowercase()
            )),

            ByCpeSearchWords => Ok(format!(
                "{NVD_CPE_LINK}?keywordSearch={}",
                url_argument.replace(' ', URL_SPACE)
            )),

            QueryType::ByCpeSearchStrict => {
                let first_part = build_query(ByCpeSearchWords, url_argument)?;
                Ok(format!("{first_part}&keywordExactMatch"))
            }

            QueryType::LinkTest => Ok(url_argument.to_string()),
        }
    }
}

/// Network module with functions used for HTTPS request and JSON exploration
pub mod network {
    use crate::NVD_KEY_NAME;
    use crate::database::MitreData;
    use crate::query::QueryType::LinkTest;
    use crate::query::build_query;
    use serde_json::Value;
    use std::env;
    use std::ffi::OsString;
    use termint::enums::Color;
    use termint::widgets::ToSpan;
    use ureq::Error;

    /// Parses the given response from a `ureq` request.
    ///
    /// This function takes a `Result` containing either a `serde_json::Value` or a `ureq::Error`.
    /// If the result is an error, it returns an empty `Value`.
    /// If the result is a valid response, it returns a JSON `Value`.
    ///
    /// # Arguments
    ///
    /// * `response` - A `Result` containing either a `serde_json::Value` or `ureq::Error`.
    ///
    /// # Returns
    ///
    /// * A `serde_json::Value` parsed from the response, or an empty `Value::Null` if an error occurred.
    ///
    pub fn parse_response(response: Result<Value, Box<Error>>) -> Value {
        response.unwrap_or(Value::Null)
    }

    /// Fetches a response from the given query URL. If the variable environment contains the
    /// `NVD_API_KEY`, this value will be used as NVD api key.
    ///
    /// This function uses the `ureq` crate to send an HTTP GET request to the specified URL.
    /// It returns the response if the request is successful, otherwise, it returns an error.
    /// The HTTP request is force to HTTPS only for secure reason.
    ///
    /// # Arguments
    ///
    /// * `query` - A string slice that holds the URL to which the GET request should be sent.
    ///
    /// # Returns
    ///
    /// This function returns a `Result` which is:
    /// - `Ok(serde_json::Value)` if the request is successful.
    /// - `Err(ureq::Error)` if there is an error during the request.
    ///
    /// # Examples
    ///
    /// ```
    /// use fenir::network::fetch_json_response;
    /// let url = "https://api.example.com/data";
    ///
    /// match fetch_json_response(url) {
    ///     Ok(response) => println!("Success: {:?}", response),
    ///     Err(error) => eprintln!("Error: {:?}", error),
    /// }
    /// ```
    ///
    /// # Errors
    ///
    /// This function will return an `Err` variant if the GET request fails for any reason,
    /// such as network issues or invalid URLs.
    ///
    pub fn fetch_json_response(query: &str) -> Result<Value, Box<Error>> {
        let apikey = check_nvd_api_key();
        if let Some(item) = apikey {
            let result: Value = ureq::get(query)
                .header("apiKey", item.to_str().unwrap())
                .call()?
                .body_mut()
                .with_config()
                .read_json()?;
            Ok(result)
        } else {
            let result = ureq::get(query)
                .call()?
                .body_mut()
                .with_config()
                .read_json()?;

            Ok(result)
        }
    }

    /// Check if the nvd api key is exiting
    ///
    /// # Returns
    ///
    /// - The result of checking. The presence of the NVD_API_KEY is optional
    pub fn check_nvd_api_key() -> Option<OsString> {
        env::var_os(NVD_KEY_NAME)
    }

    /// Warning missing API key message
    pub fn check_nvd_api_key_warning() {
        eprintln!("{}", "WARNING: NVD api key not found. For a better performance, in your environment set NVD_API_KEY=<your_api_key_value>.".to_string().fg(Color::DarkYellow));
    }

    /// Checks the validity of a connection by sending a GET request to the provided URL.
    ///
    /// # Arguments
    ///
    /// * `query` - A string slice that represents the URL to which the GET request is made.
    ///
    /// # Returns
    ///
    /// * `true` if the response for the GET request is successful (status code 200).
    /// * `false` if there is any error in making the request or the response indicates a failure.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use fenir::NVD_CVE_LINK;
    /// use fenir::network::validate_connection;
    ///
    /// let is_valid = validate_connection(NVD_CVE_LINK);
    /// assert!(is_valid);
    /// ```
    pub fn validate_connection(query: &str) -> bool {
        // Simple URL validation
        if !query.starts_with("http://") && !query.starts_with("https://") {
            eprintln!("Invalid URL: {}", query);
            return false;
        }

        let agent = ureq::Agent::new_with_defaults();

        let query_test = build_query(LinkTest, query);
        let query_info_for_error = query_test.clone().unwrap();

        match agent.get(query_test.unwrap().as_str()).call() {
            Ok(res) => {
                if res.status() == 200 {
                    true
                } else {
                    eprintln!(
                        "Request failed with status: {} ({})",
                        res.status(),
                        query_info_for_error
                    );
                    false
                }
            }
            Err(Error::StatusCode(res)) => {
                eprintln!(
                    "Request failed with response: {:?} ({})",
                    res, query_info_for_error
                );
                false
            }
            Err(Error::Http(transport)) => {
                eprintln!(
                    "Request http error: {} ({})",
                    transport, query_info_for_error
                );
                false
            }
            _ => false,
        }
    }

    /// Check if the Mitre data is valid for exploitation. This feature check if the URL and associated
    /// sources are available.
    ///
    /// # Argument
    /// * `data`- MitreData used for Mitre data checking
    ///
    /// If the connection is valid, it prints "valid".
    /// If the connection is invalid, it prints "invalid".
    ///
    /// # Example
    ///
    /// ```rust
    ///  use fenir::network::check_mitre_data;
    ///  use fenir::database::{MitreData, MitreDefinition};
    ///
    ///  pub struct Link;
    ///
    ///  impl MitreDefinition for Link {
    ///     fn define() -> MitreData {
    ///         MitreData {
    ///             name: "Cpe",
    ///             url: "https://services.nvd.nist.gov/rest/json/cpes/2.0",
    ///             files: vec![],
    ///         }
    ///     }
    /// }
    ///
    /// check_mitre_data(Link::define());
    /// ```
    pub fn check_mitre_data(data: MitreData) {
        println!("Check mitre domain: {}", data.name);
        if data.files.is_empty() {
            print!("\tTest url: {}... ", data.url);
            if !validate_connection(data.url) {
                eprintln!("Failed");
            } else {
                println!("Valid");
            }
        }

        data.files.iter().for_each(|&source| {
            let url_data = format!("{}/{}", data.url, source);
            print!("\tTest: {}... ", url_data);
            if !validate_connection(url_data.as_str()) {
                println!("Invalid");
            } else {
                println!("valid");
            }
        });
    }
}

/// Module for CWE structure definition and its associated functions
pub mod cwe {
    use crate::database::{MitreData, MitreDefinition, find_cwe_by_id, parse_id_to_u32};
    use crate::facilities::{Cleaning, Uppercase};
    use crate::{header, section, section_level};
    use serde_json::Value;
    use std::fmt::{Display, Formatter};
    use termint::enums::Color;
    use termint::widgets::ToSpan;

    /// Represents a CweRecord that's containing  all content of an existent CWE.
    #[derive(Clone, Eq, PartialEq, Debug)]
    pub struct CweRecord {
        /// the CWE id (without CWE string prefix)
        pub id: u32,

        /// the name of the CWE
        pub name: String,

        /// The primary description of the CWE
        pub description: String,

        /// The full description of the CWE
        pub extended: String,

        /// The associated capec
        pub attacks: String,

        /// The consequences of the CWE
        pub consequences: String,

        /// The detections feature for this CWE
        pub detections: String,

        /// The mitigations for this CWE
        pub mitigations: String,
    }

    impl Display for CweRecord {
        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
            write!(
                f,
                "{}\n{} {}",
                header!(format!("CWE-{}", self.id)),
                format!("{:>4} {}", "-", "Name:").fg(Color::DarkBlue),
                self.name
            )
        }
    }

    impl MitreDefinition for CweRecord {
        fn define() -> MitreData {
            MitreData {
                name: "Cwe",
                url: "https://cwe.mitre.org/data/csv",
                files: vec!["699.csv.zip", "1000.csv.zip", "1194.csv.zip"],
            }
        }
    }

    /// Shows the weaknesses whose the ids are corresponding to the `raw_weaknesses` string.
    ///
    /// # Argument
    ///
    /// * `section` - Section to show as section level/
    /// * `raw_weaknesses`- The string of weaknesses id. This string is the format: `::<id1>::<id2>::...::<idN>::`.
    ///
    pub fn show_weaknesses(section: &str, raw_weaknesses: String) {
        let cwe_list = parse_id_to_u32(raw_weaknesses);

        section_level!(2, section);
        for cwe in cwe_list {
            let result = find_cwe_by_id(cwe);
            if let Some(record) = result {
                println!("{:>6} CWE-{} - {}", "-", cwe, record.name);
            } else {
                println!("{:>6} CWE-{} - ???", "-", cwe);
            }
        }
    }

    /// Flat the cwe values to a string value
    ///
    /// # Arguments
    ///
    /// * `values` - List of cwe values
    ///
    /// # Returns
    ///
    /// A string with all cwe id separate by a `,`.
    pub fn join_cwe_list(values: &[Value]) -> String {
        let mut result = Vec::new();
        values
            .iter()
            .for_each(|v| result.push(String::cleaning(v["value"].to_string())));

        result.join(", ")
    }
}

/// Module for CPE structure definition and its associated functions
pub mod cpe {
    use crate::database::{MitreData, MitreDefinition};
    use crate::facilities::Uppercase;
    use crate::package::errors::write_error_message_and_exit;
    use crate::{NOT_ENOUGH_ELEMENTS_ERROR, stamp};
    use std::fmt::{Display, Formatter};

    /// NVD link Rest API for CPE request
    pub const NVD_CPE_LINK: &str = "https://services.nvd.nist.gov/rest/json/cpes/2.0";

    /// NVD link Rest API for CPE/CVE matching
    pub const NVD_CPE_MATCH_LINK: &str = "https://services.nvd.nist.gov/rest/json/cpematch/2.0";

    /// Represents a Common Platform Enumeration (CPE) identifier.
    ///
    /// CPE is a standardized method used to describe and identify classes of applications,
    /// operating systems, and hardware devices present within an enterprise's computing assets.
    ///
    /// This struct includes various fields that together form a complete CPE identifier.
    ///
    /// # Note
    ///
    /// All fields that are not explicitly specified, are marked with the `*` character.
    ///
    #[derive(Eq, PartialEq, Clone, Debug, Default)]
    pub struct Cpe {
        /// Type CPE type
        pub cpe_type: CpeType,

        /// The product's vendor.
        pub vendor: String,

        /// The product's name.
        pub product: String,

        /// The product's version.
        pub version: String,

        /// The update indication related to this version.
        pub update: String,

        /// The product's edition.
        pub edition: String,

        /// The product's language.
        pub language: String,

        /// The software edition.
        pub sw_edition: String,

        /// The target software.
        pub target_sw: String,

        /// The target hardware.
        pub target_hw: String,

        /// The other field for free indication.
        pub other: String,
    }

    impl Cpe {
        /// Creates a new instance of the `cpe` struct with the provided `CpeType`.
        ///
        /// Fields such as `vendor`, `product`, `version`, `update`, and `edition` are initialized with default values (`"*"`).
        ///
        /// # Arguments
        ///
        /// * `cpe_type` - The type of the Common Platform Enumeration (CPE). This can be either `CpeType::Application` or `CpeType::OperatingSystem`.
        ///
        /// # Returns
        ///
        /// A new `cpe` instance with the specified CPE type and default field values.
        pub fn new(cpe_type: CpeType) -> Self {
            Cpe {
                cpe_type,
                vendor: "*".to_string(),
                product: "*".to_string(),
                version: "*".to_string(),
                update: "*".to_string(),
                edition: "*".to_string(),
                language: "*".to_string(),
                sw_edition: "*".to_string(),
                target_hw: "*".to_string(),
                target_sw: "*".to_string(),
                other: "*".to_string(),
            }
        }

        /// Returns a string representation of the instance. This is a convenience method for
        /// formats the instance into a string using the `Display` trait implementation
        /// of the type of `self`.
        ///
        /// # Returns
        ///
        /// A `String` containing the formatted representation of the instance.
        ///
        /// # Notes:
        ///
        /// - the output format is : cpe:2.3:&lt;part&gt;:&lt;vendor&gt;:&lt;product&gt;:&lt;version&gt;:&lt;update&gt;:&lt;edition&gt;
        /// - the output format is limited with elements only used with these tools:
        ///     - &lt;part&gt;: support only o (for operating system, a for application),
        ///     - the &lt;sw_edition&gt;:&lt;target_sw&gt;:&lt;target_hw&gt;:&lt;other&gt; of the CPE norm is not supported.
        ///
        pub fn name(&self) -> String {
            format!("{}", self)
        }

        /// Sets the vendor field for this `cpe` instance.
        ///
        /// This method updates the vendor field with the provided name, converting it to lowercase.
        ///
        /// # Arguments
        ///
        /// * `name` - A string slice that holds the name of the vendor.
        ///
        /// # Example
        ///
        /// ```
        /// use fenir::cpe::{Cpe, CpeType};
        /// let mut cpe = Cpe::new(CpeType::Application);
        ///
        /// cpe.vendor("NewVendor");
        /// assert_eq!(cpe.vendor, "newvendor");
        /// ```
        pub fn vendor(&mut self, name: &str) {
            self.vendor = String::from(name).to_lowercase();
        }

        /// Sets the product name for the CPE identifier.
        ///
        /// This method takes a string slice representing the product name,
        /// converts it to lowercase, and assigns it to the `product` field of the `cpe` struct.
        ///
        /// # Parameters
        ///
        /// * `name` - A string slice that holds the name of the product. This name will be converted to lowercase.
        ///
        /// # Example
        ///
        /// ```
        /// use fenir::cpe::{Cpe, CpeType};
        /// let mut cpe = Cpe::new(CpeType::Application);
        ///
        /// cpe.product("CoolProduct");
        /// assert_eq!(cpe.product, "coolproduct");
        /// ```
        pub fn product(&mut self, name: &str) {
            self.product = String::from(name).to_lowercase();
        }

        /// Sets the version for the `cpe` instance.
        ///
        /// This method updates the `version` field of the `cpe` struct, converting the provided
        /// version string to lowercase to ensure consistency.
        ///
        /// # Parameters
        ///
        /// * `value` - A reference to a string slice representing the new version to be set.
        ///
        /// # Example
        ///
        /// ```
        /// use fenir::cpe::{Cpe, CpeType};
        /// let mut cpe = Cpe::new(CpeType::Application);
        ///
        /// cpe.version("2.0.0");
        /// assert_eq!(cpe.version, "2.0.0");
        /// ```
        ///
        /// # Note
        ///
        /// The input version string will be converted to lowercase.
        ///
        /// # Errors
        ///
        /// This method does not return an error but mutates the `cpe` instance in place.
        pub fn version(&mut self, value: &str) {
            self.version = String::from(value).to_lowercase();
        }

        /// Updates the `update` field of the `cpe` struct with the given value, converting it to lowercase.
        ///
        /// # Arguments
        ///
        /// * `value` - A string slice representing the new update/version details of the product.
        ///
        /// # Examples
        ///
        /// ```
        /// use fenir::cpe::{Cpe, CpeType};
        /// let mut cpe = Cpe::new(CpeType::Application);
        ///
        /// cpe.update("Update2");
        /// assert_eq!(cpe.update, "update2");
        /// ```
        pub fn update(&mut self, value: &str) {
            self.update = String::from(value).to_lowercase();
        }

        /// Sets the edition field of the `cpe` struct.
        ///
        /// This method takes a string slice, converts it to a `String`, transforms it to lowercase,
        /// and assigns it to the inner field.
        ///
        /// # Arguments
        ///
        /// * `value` - A string slice that holds the new value for this field.
        ///
        /// # Example
        ///
        /// ```rust
        /// use fenir::cpe::{Cpe, CpeType};
        /// let mut cpe = Cpe::new(CpeType::Application);
        ///
        /// cpe.edition("Premium");
        /// assert_eq!(cpe.edition, "premium");
        /// ```
        pub fn edition(&mut self, value: &str) {
            self.edition = String::from(value).to_lowercase();
        }

        /// Sets the language of the `cpe` struct.
        ///
        /// This method takes a string slice, converts it to a `String`, transforms it to lowercase,
        /// and assigns it to the inner field.
        ///
        /// # Arguments
        ///
        /// * `value` - A string slice that holds the new value for this field.
        ///
        /// # Example
        ///
        /// ```rust
        /// use fenir::cpe::{Cpe, CpeType};
        /// let mut cpe = Cpe::new(CpeType::Application);
        ///
        /// cpe.language("EN");
        /// assert_eq!(cpe.language, "en");
        /// ```
        pub fn language(&mut self, value: &str) {
            self.language = String::from(value).to_lowercase();
        }

        /// Sets the software edition of the `cpe` struct.
        ///
        /// This method takes a string slice, converts it to a `String`, transforms it to lowercase,
        /// and assigns it to the inner field.
        ///
        /// # Arguments
        ///
        /// * `value` - A string slice that holds the new value for this field.
        ///
        /// # Example
        ///
        /// ```rust
        /// use fenir::cpe::{Cpe, CpeType};
        /// let mut cpe = Cpe::new(CpeType::Application);
        ///
        /// cpe.sw_edition("SoftEdition");
        /// assert_eq!(cpe.sw_edition, "softedition");
        /// ```
        pub fn sw_edition(&mut self, value: &str) {
            self.sw_edition = String::from(value).to_lowercase();
        }

        /// Sets the target software of the `cpe` struct.
        ///
        /// This method takes a string slice, converts it to a `String`, transforms it to lowercase,
        /// and assigns it to the inner field.
        ///
        /// # Arguments
        ///
        /// * `value` - A string slice that holds the new value for this field.
        ///
        /// # Example
        ///
        /// ```rust
        /// use fenir::cpe::{Cpe, CpeType};
        /// let mut cpe = Cpe::new(CpeType::Application);
        ///
        /// cpe.target_sw("TargetSoft");
        /// assert_eq!(cpe.target_sw, "targetsoft");
        /// ```
        pub fn target_sw(&mut self, value: &str) {
            self.target_sw = String::from(value).to_lowercase();
        }

        /// Sets the target hardware of the `cpe` struct.
        ///
        /// This method takes a string slice, converts it to a `String`, transforms it to lowercase,
        /// and assigns it to the inner field.
        ///
        /// # Arguments
        ///
        /// * `value` - A string slice that holds the new value for this field.
        ///
        /// # Example
        ///
        /// ```rust
        /// use fenir::cpe::{Cpe, CpeType};
        /// let mut cpe = Cpe::new(CpeType::Application);
        ///
        /// cpe.target_hw("Raspberry");
        /// assert_eq!(cpe.target_hw, "raspberry");
        /// ```
        pub fn target_hw(&mut self, value: &str) {
            self.target_hw = String::from(value).to_lowercase();
        }

        /// Sets the other value of the `cpe` struct.
        ///
        /// This method takes a string slice, converts it to a `String`, transforms it to lowercase,
        /// and assigns it to the inner field.
        ///
        /// # Arguments
        ///
        /// * `value` - A string slice that holds the new value for this field.
        ///
        /// # Example
        ///
        /// ```rust
        /// use fenir::cpe::{Cpe, CpeType};
        /// let mut cpe = Cpe::new(CpeType::Application);
        ///
        /// cpe.other("Other");
        /// assert_eq!(cpe.other, "other");
        /// ```
        pub fn other(&mut self, value: &str) {
            self.other = String::from(value).to_lowercase();
        }

        /// Parses a CPE (Common Platform Enumeration) from a given string. Support only cpe version 2.3.
        ///
        /// # Arguments
        /// * `cpe_string` - A string in the CPE format to be parsed
        ///
        /// # Returns
        /// * `cpe` - A struct containing the parsed components of the CPE string
        ///
        /// # Notes:
        ///
        /// - the output format is : cpe:2.3:&lt;part&gt;:&lt;vendor&gt;:&lt;product&gt;:&lt;version&gt;:&lt;update&gt;:&lt;edition&gt;
        /// - the output format is limited with elements only used with these tools:
        ///     - &lt;part&gt;: support only o (for operating system, a for application),
        ///     - the &lt;sw_edition&gt;:&lt;target_sw&gt;:&lt;target_hw&gt;:&lt;other&gt; of the CPE norm is not supported.
        ///
        pub fn from(cpe_string: &str) -> Cpe {
            if !cpe_string.contains(CPE_HEADER) {
                write_error_message_and_exit("CPE string header not found: cpe:2.3", None);
            }

            let elements = extract_elements(cpe_string);
            let mut cpe = match elements[2].as_str() {
                "o" => Cpe::new(CpeType::OperatingSystem),
                "a" => Cpe::new(CpeType::Application),
                "h" => Cpe::new(CpeType::Hardware),
                _ => Cpe::new(CpeType::All),
            };

            cpe.vendor(&elements[3]);
            cpe.product(&elements[4]);
            cpe.version(&elements[5]);
            cpe.update(&elements[6]);
            cpe.edition(&elements[7]);
            cpe.language(&elements[8]);
            cpe.sw_edition(&elements[9]);
            cpe.target_sw(&elements[10]);
            cpe.target_hw(&elements[11]);
            cpe.other(&elements[12]);
            cpe
        }

        /// Describes the CPE (Common Platform Enumeration) attributes.
        ///
        /// This method prints out a human-readable description of the CPE,
        /// detailing its type, vendor, product, version, edition, and update.
        ///
        /// The type is either "soft" for applications or "os" for operating systems,
        /// inferred from the `cpe_type` field.
        ///
        /// # Examples
        ///
        /// ```rust
        /// use fenir::cpe::{Cpe, CpeType};
        ///
        /// let cpe = Cpe::from("cpe:2.3:a:lostvip:ruoyi-go:*:*:*:*:*:*:*:*");
        ///
        /// cpe.explains();
        /// ```
        /// Will produce the output:
        /// ```shell
        ///   - Id: cpe:2.3:a:lostvip:ruoyi-go:*:*:*:*:*:*:*:*
        ///   - Type: soft
        ///   - Vendor: lostvip
        ///   - Product: ruoyi-go
        ///   - Version: *
        ///   - Edition: *
        ///   - Update: *
        ///   - Language: *
        ///   - Sw_edition: *
        ///   - Target sw : *
        ///   - Target hw: *
        ///   - Other: *
        /// ```
        pub fn explains(&self) {
            stamp!("id", &self.name());
            stamp!("type", self.cpe_type());
            stamp!("vendor", &self.vendor);
            stamp!("product", &self.product);
            stamp!("version", &self.version);
            stamp!("edition", &self.edition);
            stamp!("update", &self.update);
            stamp!("language", &self.language);
            stamp!("sw edition", &self.sw_edition);
            stamp!("target sw", &self.target_sw);
            stamp!("target hw", &self.target_hw);
            stamp!("other", &self.other);
        }

        /// Returns the CPE type description
        ///
        /// # Returns
        ///
        ///  * "soft" - if type is application (a)
        ///  * "hardware" -  if type is hardware (h)
        ///  * "os" - if type is operating system (o)
        ///  * "all" - if type is all (*)
        ///
        /// # Example
        ///
        /// ```rust
        ///  use fenir::cpe::{Cpe, CpeType};
        ///
        /// let cpe = Cpe::new(CpeType::OperatingSystem);
        /// assert_eq!("os", cpe.cpe_type());
        /// ```
        pub fn cpe_type(&self) -> &str {
            match self.cpe_type {
                CpeType::Application => "soft",
                CpeType::OperatingSystem => "os",
                CpeType::Hardware => "hard",
                CpeType::All => "all",
            }
        }
    }

    /// CpeLink used for CPE request.
    pub struct CpeLink;
    impl MitreDefinition for CpeLink {
        fn define() -> MitreData {
            MitreData {
                name: "Cpe",
                url: "https://services.nvd.nist.gov/rest/json/cpes/2.0",
                files: vec![],
            }
        }
    }

    /// CpeMatchLink used for cpe link complement
    pub struct CpeMatchLink;
    impl MitreDefinition for CpeMatchLink {
        fn define() -> MitreData {
            MitreData {
                name: "Cpe match",
                url: "https://services.nvd.nist.gov/rest/json/cpematch/2.0",
                files: vec![],
            }
        }
    }

    /// Operating system type
    pub const CPE_OS_LABEL: &str = "os";
    // Hardware type
    pub const CPE_HARDWARE_LABEL: &str = "h";
    /// Application/software type
    pub const CPE_SOFT_LABEL: &str = "soft";
    /// All type
    pub const CPE_ALL_LABEL: &str = "*";

    /// Creates a `cpe` instance based on the provided application type.
    ///
    /// This function checks if the `apps_type` matches the constant value `OS_TYPE`.
    /// If it does, it creates a `cpe` instance of type `OperatingSystem`, otherwise it creates a
    /// `cpe` instance of type `Application`.
    ///
    /// # Arguments
    ///
    /// * `apps_type` - A string slice representing the type of the application. It can be either
    ///   `"os"` for an operating system or any other value for an application.
    ///
    /// # Returns
    ///
    /// A `cpe` instance with the appropriate `CpeType`.
    ///
    /// # Examples
    ///
    /// ```
    /// use fenir::cpe::{create_cpe_from_type, Cpe, CpeType};
    ///
    /// let cpe_os = create_cpe_from_type("os");
    /// assert_eq!(cpe_os.cpe_type, CpeType::OperatingSystem);
    ///
    /// let cpe_app = create_cpe_from_type("soft");
    /// assert_eq!(cpe_app.cpe_type, CpeType::Application);
    /// ```
    pub fn create_cpe_from_type(apps_type: &str) -> Cpe {
        match apps_type {
            CPE_OS_LABEL => Cpe::new(CpeType::OperatingSystem),
            CPE_SOFT_LABEL => Cpe::new(CpeType::Application),
            CPE_HARDWARE_LABEL => Cpe::new(CpeType::Hardware),
            _ => Cpe::new(CpeType::All),
        }
    }

    /// Returns a string representation of the instance.
    ///
    /// # Returns
    ///
    /// A `String` containing the formatted representation of the instance.
    ///
    /// # Notes:
    ///
    /// - the output format is : cpe:2.3:&lt;part&gt;:&lt;vendor&gt;:&lt;product&gt;:&lt;version&gt;:&lt;update&gt;:&lt;edition&gt;
    /// - the output format is limited with elements only used with these tools:
    ///     - &lt;part&gt;: support only o (for operating system, a for application),
    ///     - the &lt;sw_edition&gt;:&lt;target_sw&gt;:&lt;target_hw&gt;:&lt;other&gt; of the CPE norm is not supported.
    ///
    impl Display for Cpe {
        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
            let soft_type = match self.cpe_type {
                CpeType::Application => "a",
                CpeType::OperatingSystem => "o",
                CpeType::Hardware => "h",
                CpeType::All => "*",
            };

            write!(
                f,
                "{}:{}:{}:{}:{}:{}:{}:{}:{}:{}:{}:{}",
                CPE_HEADER,
                soft_type,
                self.vendor,
                self.product,
                self.version,
                self.update,
                self.edition,
                self.language,
                self.sw_edition,
                self.target_sw,
                self.target_hw,
                self.other
            )
        }
    }

    /// Represents different types of Common Platform Enumeration (CPE) identifiers.
    ///
    /// CPE is a standardized method of describing and identifying classes of
    /// applications, operating systems, and hardware devices present among an enterprise's computing assets.
    ///
    /// # Variants
    ///
    /// - `All`: Represents all type of products.
    /// - `Application`: Represents a software application.
    /// - `OperatingSystem`: Represents an operating system.
    ///
    #[derive(Eq, PartialEq, Clone, Debug, Default)]
    pub enum CpeType {
        #[default]
        All,
        Application,
        OperatingSystem,
        Hardware,
    }

    impl Display for CpeType {
        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
            let value = match self {
                CpeType::All => "*",
                CpeType::Application => "application",
                CpeType::OperatingSystem => "Os",
                CpeType::Hardware => "hardware",
            };

            f.write_str(value)
        }
    }

    /// CPE request header that's identifying the release used (cpe v 2.3)
    const CPE_HEADER: &str = "cpe:2.3";

    /// Extracts elements from a Common Platform Enumeration (CPE) string by splitting it on colons (`:`)
    /// and converting each element to lowercase.
    ///
    /// If the number of elements in the CPE string is less than or equal to 8, this function will write an
    /// error message and exit the process with a status code of 1.
    ///
    /// # Arguments
    ///
    /// * `cpe_string` - A string slice representing the CPE string to be parsed.
    ///
    /// # Returns
    ///
    /// A vector of strings, each representing an element of the CPE string.
    ///
    /// # Panics
    ///
    /// This function will exit the process if the number of elements is less than or equal to 8.
    ///
    /// # Examples
    ///
    /// ```
    /// use fenir::cpe::extract_elements;
    ///
    /// let cpe = "cpe:2.3:o:vendor:product:version:update:edition:language:*:*:*";
    /// let elements = extract_elements(cpe);
    /// assert!(elements.len() > 8);
    /// ```
    pub fn extract_elements(cpe_string: &str) -> Vec<String> {
        let elements: Vec<String> = cpe_string.split(':').map(|s| s.to_lowercase()).collect();
        if elements.len() <= 8 {
            write_error_message_and_exit(NOT_ENOUGH_ELEMENTS_ERROR, None);
        }
        elements
    }
}

/// Shows the version given as argument
///
/// # Arguments
///
/// * `version` - A string that's describing the version.
///
pub fn show_version(version: &str) {
    println!("Version: {}", version);
    println!("(fenir lib version: {})", env!("CARGO_PKG_VERSION"));
}

/// Module for CVE structure definition and its associated functions
pub mod cve {
    use crate::cwe::join_cwe_list;
    use crate::database::{MitreData, MitreDefinition};
    use crate::facilities::Cleaning;
    use serde_json::Value;
    use std::fmt::{Display, Formatter};

    /// The CVE score value. The score value is corresponding to the standard CVE NVD score.
    #[derive(Default, PartialEq, Clone, PartialOrd, Ord, Eq)]
    pub struct Score {
        score: String,
    }

    impl Score {
        /// Create a new score instance.
        ///
        /// # Argument:
        ///
        /// * `value` - string score value. This value must be a numeric forms that is conforming to the NVD standard.
        pub fn new(value: String) -> Score {
            Self { score: value }
        }

        /// Float value of the CVE score.
        ///
        ///
        /// # Return
        ///
        /// Score float value.
        pub fn value(&self) -> f64 {
            self.score.parse::<f64>().unwrap()
        }

        /// Score's label. This label shown is depending on the score value as the NVD standard definition.
        ///
        /// # Return
        ///
        /// The score label.
        ///
        /// # Example
        ///
        /// ```rust
        /// use fenir::cve::Score;
        ///
        /// let score = Score::new("5.2".to_string());
        ///
        /// assert_eq!("MEDIUM", score.label());
        /// ```
        pub fn label(&self) -> &str {
            match self.value() {
                0.0 => "None",
                value if value > 0.0 && value < 4.0 => "LOW",
                value if (4.0..7.0).contains(&value) => "MEDIUM",
                value if (7.0..9.0).contains(&value) => "HIGH",
                _ => "CRITICAL",
            }
        }
    }

    /// Represents a CVE with a reference.
    #[derive(PartialEq, PartialOrd, Ord, Eq, Default)]
    pub struct Cve {
        /// The CVE reference like: CVE-2024-12021
        pub reference: String,

        /// Optional description. Some new CVE can have no description.
        pub description: Option<String>,

        /// Optional score CVSS3. Some new CVE can have no score.
        pub score_v3: Option<Score>,

        /// Optional score CVSS4. Some new CVE can have no score.
        pub score_v4: Option<Score>,

        /// Optional CPE identification links with this CVE. Some new CVE can have no cpe id.
        pub cpe_id: Option<String>,

        /// Optional weaknesses links with this CVE. Some new CVE can have no weaknesses (cwe).
        pub weaknesses: Option<String>,
    }

    impl Cve {
        /// Create a new CVE.
        ///
        /// # Argument
        ///
        /// * `reference`- The CVE reference
        ///
        /// # Return
        ///
        /// A new instance.
        ///
        /// # Example
        ///
        /// ```rust
        /// use fenir::cve::Cve;
        /// let cve = Cve::new("CVE-2025-12040".to_string());
        ///
        /// assert_eq!("CVE-2025-12040", cve.reference);
        /// ```
        pub fn new(reference: String) -> Self {
            Self {
                reference,
                ..Default::default()
            }
        }
    }

    impl Display for Cve {
        fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
            write!(formatter, "{}", String::cleaning(self.reference.clone()))
        }
    }

    /// NVD url link Rest API for CVE queries.
    impl MitreDefinition for Cve {
        fn define() -> MitreData {
            MitreData {
                name: "Cve",
                url: "https://services.nvd.nist.gov/rest/json/cves/2.0",
                files: vec![],
            }
        }
    }

    /// Create a CVE from the raw value
    ///
    /// # Arguments
    ///
    /// * `value`- Raw value
    ///
    /// # Returns
    ///
    /// The CVE
    pub fn create_cve_from(value: &Value) -> Cve {
        let mut cve = Cve::new(String::cleaning(value["cve"]["id"].to_string()));
        cve.description = Some(String::cleaning(
            value["cve"]["descriptions"][0]["value"].to_string(),
        ));

        let score_value =
            value["cve"]["metrics"]["cvssMetricV31"][0]["cvssData"]["baseScore"].to_string();
        cve.score_v3 = match score_value.as_str() {
            "null" | "None" => Some(Score::new("0.0".to_string())),
            _ => Some(Score::new(score_value)),
        };

        let score_value =
            value["cve"]["metrics"]["cvssMetricV40"][0]["cvssData"]["baseScore"].to_string();
        cve.score_v4 = match score_value.as_str() {
            "null" | "None" => Some(Score::new("0.0".to_string())),
            _ => Some(Score::new(score_value)),
        };

        let cwe = value["cve"]["weaknesses"][0]["description"].as_array();
        cve.weaknesses = match cwe {
            Some(_) => Some(String::cleaning(join_cwe_list(cwe.unwrap()))),
            None => Some(String::from("None")),
        };

        let optional_cpe = value["cve"]["configurations"][0]["nodes"][0]["cpeMatch"].as_array();
        if let Some(cpe_id) = optional_cpe {
            cve.cpe_id = Some(String::cleaning(
                cpe_id.first().unwrap()["criteria"].to_string(),
            ));
        } else {
            cve.cpe_id = Some(String::from("None"));
        }

        cve
    }

    /// Extracts a list of CVE (Common Vulnerabilities and Exposures) references
    /// from a given JSON value that contains CWE (Common Weakness Enumeration) data.
    ///
    /// # Arguments
    ///
    /// * `cwe_list` - A JSON value that contains a list of vulnerabilities under the key `"vulnerabilities"`.
    ///
    /// # Returns
    ///
    /// This function returns a vector of `Cve` structs, each containing the reference (`id`) of a CVE.
    ///
    /// # Example
    ///
    /// ```rust
    /// use serde_json::json;
    /// use fenir::cve::cve_from_cwe;
    ///
    /// let cwe_json = json!({
    ///     "vulnerabilities": [
    ///         { "cve": { "id": "CVE-2021-1234" }},
    ///         { "cve": { "id": "CVE-2021-5678" }}
    ///     ]
    /// });
    ///
    /// let cves = cve_from_cwe(&cwe_json);
    /// assert_eq!(cves.len(), 2);
    /// assert_eq!(cves[0].reference, "CVE-2021-1234");
    /// assert_eq!(cves[1].reference, "CVE-2021-5678");
    /// ```
    ///
    /// # Note
    ///
    /// It is assumed that the `Cve` struct is defined elsewhere in your codebase.
    /// Below is an example of how `Cve` might be defined:
    ///
    /// ```rust
    /// #[derive(PartialEq, PartialOrd, Ord, Eq)]
    /// pub struct Cve {
    ///     pub reference: String,
    /// }
    /// ```
    pub fn cve_from_cwe(cwe_list: &Value) -> Vec<Cve> {
        let mut result: Vec<Cve> = vec![];
        let binding = cwe_list["vulnerabilities"].as_array();
        if let Some(_item) = binding {
            let lines = binding.unwrap();
            lines
                .iter()
                .for_each(|line| result.push(create_cve_from(line)))
        }

        result
    }
}

/// Module for CAPEC structure definition and its associated functions.
pub mod capec {
    use crate::database::{MitreData, MitreDefinition, find_capec_by_id, parse_id_to_u32};
    use crate::facilities::{
        FIELD_SEPARATOR_STRING, FIELD_SEPARATOR_STRING_LONG, Standardize, Uppercase,
    };
    use crate::{header, section};
    use std::fmt::{Display, Formatter};
    use termint::enums::Color;
    use termint::widgets::ToSpan;

    /// Structure for a CAPEC record
    #[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
    pub struct CapecRecord {
        /// Capec's id
        pub id: u32,

        /// Capec's name
        pub name: String,

        /// Capec's abstraction
        pub abstraction: String,

        /// Capec's status
        pub status: String,

        /// Capec's description
        pub description: String,

        /// Capec's Likelihood
        pub likelihood: String,

        /// Capec's alternate terms
        pub alternates: String,

        /// Capec's severity
        pub severity: String,

        /// Capec's flow
        pub flow: String,

        /// Capec's related attack terms
        pub attacks: String,

        /// Capec prerequisites
        pub prerequisites: String,

        /// Capec's consequences
        pub consequences: String,

        /// Capec's skills
        pub skills: String,

        /// Capec's resources
        pub resources: String,

        /// Capec's indicators
        pub indicators: String,

        /// Capec mitigations
        pub mitigations: String,

        /// Capec weaknesses
        pub weaknesses: String,

        /// Capec's instances
        pub instances: String,

        /// Capec's taxonomy
        pub taxonomy: String,
    }

    impl Display for CapecRecord {
        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
            write!(
                f,
                "{}\n{} {} (Abstraction: {}. Status: {}.)",
                header!(format!("CAPEC-{}", self.id)),
                format!("{:>4} {}", "︎-", "Name:").fg(Color::DarkBlue),
                self.name,
                self.abstraction,
                self.status
            )
        }
    }

    /// Capec's url to get all .csv.zip files to load into the internal database.
    impl MitreDefinition for CapecRecord {
        fn define() -> MitreData {
            MitreData {
                name: "Capec",
                url: "https://capec.mitre.org/data/csv",
                files: vec![
                    "282.csv.zip",
                    "283.csv.zip",
                    "284.csv.zip",
                    "483.csv.zip",
                    "553.csv.zip",
                    "683.csv.zip",
                    "703.csv.zip",
                    "1000.csv.zip",
                    "2000.csv.zip",
                ],
            }
        }
    }

    /// Shows the list of attacks describing into the string value. Each id value is separating from
    /// each value with a `:` characters, as: `:<id_1>:<id_2>:...:<id_n>:`. The `id` value is the
    /// CAPEC's id.
    ///
    /// # Arguments
    /// * `attacks` - List of CAPEC's ids.
    ///
    pub fn show_attacks(attacks: String) {
        let capec_list = parse_id_to_u32(attacks);
        if capec_list.is_empty() {
            println!("{:>4} None", "-");
            return;
        }

        for capec_id in capec_list {
            let result = find_capec_by_id(capec_id);
            if let Some(record) = result {
                println!("{:>4} CAPEC-{} - {}", "-", capec_id, record.name);
            } else {
                println!("{:>4} CAPEC-{} - ???", "-", capec_id);
            }
        }
    }

    /// Return the list of Mitre Att&ck' ids from the given taxonomy.
    ///
    /// # Arguments
    /// * `taxonomy`- CAPEC's taxonomy.
    ///
    /// # Returns
    /// The list of Mitre Att&ck's ids from the taxonomy.
    pub fn extract_mitre_attack_ids(taxonomy: String) -> Vec<String> {
        let normalized_taxonomy =
            taxonomy.standardize(vec!["TAXONOMY NAME", "ENTRY ID", "ENTRY NAME"]);

        let mut result = Vec::new();

        if !normalized_taxonomy.is_empty() {
            let sections = normalized_taxonomy.split(FIELD_SEPARATOR_STRING_LONG);
            sections.for_each(|section| {
                let cells = section
                    .split(FIELD_SEPARATOR_STRING)
                    .filter(|cell| !cell.is_empty())
                    .collect::<Vec<&str>>();

                let is_mitre = cells.contains(&"TAXONOMY NAME") && cells.contains(&"attack");
                if is_mitre {
                    result.push(cells[3].to_owned());
                }
            });
        }

        result
    }
}

/// Error message for error on not enough element during parsing
const NOT_ENOUGH_ELEMENTS_ERROR: &str = "Not enough elements for parsing";

/// Module for Mitre Att&ck structure definition and its associated functions.
pub mod mitre {

    /// Describes a mitre record. If some values are not existing into the database, the corresponding field is empty.
    pub struct MitreRecord {
        /// The Mitre's id
        pub id: String,

        /// The name of this mitre record
        pub name: String,

        /// The description of this mitre record
        pub description: String,

        /// The URL associated with this record. This URL allows to get more information for example.
        pub url: String,

        /// The creation date.
        pub created: String,

        /// The last updating date.
        pub modified: String,

        /// The domain for this mitre record. If several domains are existing, this string contains all these separated by a comma.
        pub domain: String,

        /// The version of this record.
        pub version: String,

        /// The associated tactics for this mitre record. If several tactics are existing, this string contains all these separated by a comma.
        pub tactics: String,

        /// The list of platforms. If several platforms are existing, this string contains all these separated by a comma.
        pub platforms: String,

        /// Associated sub-techniques.
        pub sub_techniques: String,

        /// The list of contributors. If several contributors are existing, this string contains all these separated by a comma.
        pub contributors: String,

        /// Status that indicate if this Mitre record support the remote mode or not.
        pub support_remote: String,

        /// Type of impact of this attack
        pub impact_type: String,

        /// The list of citations that are using to document this Mitre record. If several contributors are existing, this string contains all these separated by a comma.
        pub citations: String,

        /// Type of tactic used with this Mitre record
        pub tactic_type: String,

        /// MTC's id used for the `Mobile` attack domain.
        pub mtc_id: String,
    }
}

#[cfg(test)]
mod tests {
    use std::thread::sleep;
    use std::time::Duration;

    fn setup() {
        let waiting = Duration::from_millis(30);
        sleep(waiting);
    }

    mod query {
        use crate::network::validate_connection;
        use crate::tests::setup;
        use crate::{NVD_CVE_LINK, NVD_KEY_NAME};
        use std::env;

        #[test]
        fn nvd_api_key_valid() {
            setup();

            let env_var = env::var_os(NVD_KEY_NAME);
            if env_var.is_some() {
                let result = validate_connection(NVD_CVE_LINK);
                assert_eq!(result, true);
            } else {
                panic!("No NVD_API_KEY found");
            }
        }

        #[test]
        fn is_connection_valid_url_validate() {
            setup();

            assert!(validate_connection(NVD_CVE_LINK));
        }

        #[test]
        fn is_connection_invalid_url_invalidate() {
            assert!(!validate_connection("http://foobar.local"));
        }

        mod build_query {
            use crate::NVD_CVE_LINK;
            use crate::facilities::get_current_date;
            use crate::query::QueryType::{ByCve, ByCveNew, ByCveUpdated, ByCwe};
            use crate::query::build_query;
            use crate::tests::setup;

            #[test]
            fn build_query_cve_valid() {
                setup();

                let result = format!("{NVD_CVE_LINK}?cveId=CVE-2020-2102");

                assert_eq!(result, build_query(ByCve, "CVE-2020-2102").unwrap());
            }

            #[test]
            fn build_query_cve_lowercase_valid() {
                setup();

                let result = format!("{NVD_CVE_LINK}?cveId=CVE-2020-2102");

                assert_eq!(result, build_query(ByCve, "cve-2020-2102").unwrap());
            }

            #[test]
            fn build_query_cwe_valid() {
                setup();

                let result = format!("{NVD_CVE_LINK}?cweId=CWE-287");

                assert_eq!(result, build_query(ByCwe, "CWE-287").unwrap());
            }

            #[test]
            fn build_query_cwe_lowercase_valid() {
                setup();

                let result = format!("{NVD_CVE_LINK}?cweId=CWE-287");

                assert_eq!(result, build_query(ByCwe, "cwe-287").unwrap());
            }

            #[test]
            fn build_query_new_dates_valid() {
                let result = build_query(ByCveNew, "2024-02-10;2024-03-10");

                assert_eq!(
                    "https://services.nvd.nist.gov/rest/json/cves/2.0?pubStartDate=2024-02-10T00:00:00.000&pubEndDate=2024-03-10T00:00:00.000",
                    result.unwrap().as_str()
                );
            }

            #[test]
            fn build_query_new_dates_default() {
                setup();

                let result = build_query(ByCveNew, "");
                let ref_date = format!(
                    "{NVD_CVE_LINK}?pubStartDate={}T00:00:00.000&pubEndDate={}T00:00:00.000",
                    get_current_date(),
                    get_current_date()
                );

                assert_eq!(ref_date, result.unwrap());
            }

            #[test]
            fn build_query_partial_date_first_default() {
                setup();

                let result = build_query(ByCveNew, ";2024-01-01");
                let ref_date = format!(
                    "{NVD_CVE_LINK}?pubStartDate={}T00:00:00.000&pubEndDate=2024-01-01T00:00:00.000",
                    get_current_date()
                );

                assert_eq!(ref_date, result.unwrap());
            }

            #[test]
            fn build_query_partial_date_last_default() {
                setup();

                let result = build_query(ByCveNew, "2024-01-01;");
                let ref_date = format!(
                    "{NVD_CVE_LINK}?pubStartDate=2024-01-01T00:00:00.000&pubEndDate={}T00:00:00.000",
                    get_current_date()
                );

                assert_eq!(ref_date, result.unwrap());
            }

            #[test]
            fn build_query_updated_valid() {
                setup();

                let result = build_query(ByCveUpdated, "2024-01-01;2024-02-01");

                assert_eq!(
                    format!(
                        "{NVD_CVE_LINK}?lastModStartDate=2024-01-01T00:00:00.000&lastModEndDate=2024-02-01T00:00:00.000"
                    ),
                    result.unwrap()
                );
            }

            #[test]
            fn build_query_updated_default_valid() {
                setup();

                let result = build_query(ByCveUpdated, "");

                assert_eq!(
                    format!(
                        "{NVD_CVE_LINK}?lastModStartDate={}T00:00:00.000&lastModEndDate={}T00:00:00.000",
                        get_current_date(),
                        get_current_date()
                    ),
                    result.unwrap()
                );
            }

            #[test]
            fn build_query_updated_first_valid() {
                setup();

                let result = build_query(ByCveUpdated, "2023-01-02;");

                assert_eq!(
                    format!(
                        "{NVD_CVE_LINK}?lastModStartDate=2023-01-02T00:00:00.000&lastModEndDate={}T00:00:00.000",
                        get_current_date()
                    ),
                    result.unwrap()
                );
            }

            #[test]
            fn build_query_updated_last_valid() {
                setup();

                let result = build_query(ByCveUpdated, ";2032-12-12");

                assert_eq!(
                    format!(
                        "{NVD_CVE_LINK}?lastModStartDate={}T00:00:00.000&lastModEndDate=2032-12-12T00:00:00.000",
                        get_current_date()
                    ),
                    result.unwrap()
                );
            }
        }

        mod execute_query {
            use crate::database::execute_query;
            use crate::query::QueryType::{ByCve, ByCveNew, ByCveUpdated};
            use crate::query::build_query;
            use crate::tests::setup;
            use serde_json::Value::Null;

            #[test]
            fn execute_query_valid_cve_found() {
                setup();

                let result = execute_query(build_query(ByCve, "CVE-2019-1010218"));

                assert_ne!(Null, result["resultsPerPage"]);
            }

            #[test]
            fn execute_query_invalid_cve_not_found() {
                setup();

                let result = execute_query(build_query(ByCve, "CVE-1980-0000"));

                assert_eq!(0, result["resultsPerPage"]);
            }

            #[test]
            fn execute_query_new_dates_valid() {
                setup();

                let result = execute_query(build_query(ByCveNew, "2024-01-01;2024-02-01"));

                assert_ne!(0, result["resultsPerPage"]);
            }

            #[test]
            fn execute_query_new_dates_swapped_not_valid() {
                setup();

                let result = execute_query(build_query(ByCveNew, "2024-02-01;2024-01-01"));

                assert_eq!(Null, result["resultsPerPage"]);
            }

            #[test]
            fn execute_query_new_dates_malformed_no_valid() {
                setup();

                let result = execute_query(build_query(ByCveNew, "202402-01;2024-03-01"));

                assert_eq!(Null, result["resultPerPage"]);
            }

            #[test]
            fn execute_query_update_dates_valid() {
                setup();

                let result = execute_query(build_query(ByCveUpdated, "2024-01-01;2024-02-01"));

                assert_ne!(0, result["resultsPerPage"]);
            }

            #[test]
            fn execute_query_updated_dates_swapped_not_valid() {
                setup();

                let result = execute_query(build_query(ByCveUpdated, "2024-02-01;2024-01-01"));

                assert_eq!(Null, result["resultsPerPage"]);
            }

            #[test]
            fn execute_query_updated_dates_malformed_no_valid() {
                setup();

                let result = execute_query(build_query(ByCveUpdated, "202402-01;2024-03-01"));

                assert_eq!(Null, result["resultPerPage"]);
            }
        }
    }

    mod string {
        use crate::facilities::{Categorize, Cleaning, Standardize, Transform, Uppercase, Wording};

        #[test]
        fn cleaning_ok() {
            let result = String::cleaning(String::from("\"value\""));

            assert_eq!("value", result);
        }

        #[test]
        fn cleaning_dots_ok() {
            let result = String::cleaning(String::from(":value:"));

            assert_eq!("value", result);
        }

        #[test]
        fn cleaning_no_cleaning() {
            let result = String::cleaning(String::from("value"));

            assert_eq!("value", result);
        }

        #[test]
        fn cleaning_empty_string_not_updated() {
            let result = String::cleaning(String::from(""));

            assert_eq!("", result);
        }

        #[test]
        fn only_uppercases_valid() {
            assert!(String::only_uppercases(String::from("BJDKE")));
        }

        #[test]
        fn only_uppercases_invalid() {
            assert_eq!(false, String::only_uppercases(String::from("ABDdD")));
        }

        #[test]
        fn only_uppercases_empty_invalid() {
            assert!(!String::only_uppercases(String::from("")));
        }

        #[test]
        fn only_uppercases_with_space_valid() {
            assert!(String::only_uppercases(String::from("TECHNICAL PART")));
        }

        #[test]
        fn smoothing_valid() {
            let original = String::from("::KKKK:fgte::::DFDF:fff::FFF:E::");
            let result = original.standardize(vec!["KKKK", "DFDF"]);

            assert_eq!("::KKKK:fgte::DFDF:fff:fff:e::", result);
        }

        #[test]
        fn smoothing_not_updated() {
            let original = String::from("::DKDKDKD::");
            let result = original.standardize(vec![""]);

            assert_eq!("::dkdkdkd::", result);
        }

        #[test]
        fn transform_valid() {
            let original = String::from("KKKKK fgte. DFDF");
            let result = original.transform(vec!["KKKKK", "DFDF"]);

            assert_eq!("::KKKKK: fgte. ::DFDF::", result);
        }

        #[test]
        fn wording_empty_string_valid() {
            let original = String::from("");
            let result = original.wording();

            assert_eq!("", result);
        }

        #[test]
        fn wording_associated_valid() {
            let original = String::from("wordAssociated");
            let result = original.wording();

            assert_eq!("Word associated", result);
        }

        #[test]
        fn wording_associated_inverse_valid() {
            let original = String::from("Wordassociation");
            let result = original.wording();

            assert_eq!("Wordassociation", result);
        }

        #[test]
        fn wording_not_associated_no_transformation() {
            let original = String::from("wordassociated");
            let result = original.wording();

            assert_eq!("Wordassociated", result);
        }

        #[test]
        fn wording_with_multi_words() {
            let original = String::from("OneWordAssociatedWithAnother");
            let result = original.wording();

            assert_eq!("One word associated with another", result);
        }

        #[test]
        fn wording_uppercases_lowercases_valid() {
            let original = String::from("WORDassociated");
            let result = original.wording();

            assert_eq!("Wordassociated", result);
        }

        #[test]
        fn wording_right_form_valid() {
            let original = String::from("Space");
            let result = original.wording();

            assert_eq!("Space", result);
        }

        #[test]
        fn wording_with_spaces_valid() {
            let original = String::from("Space From another World");
            let result = original.wording();

            assert_eq!("Space from another world", result);
        }

        #[test]
        fn first_uppercase_valid() {
            let original = String::from("first");
            let result = original.first_uppercase();

            assert_eq!("First", result);
        }

        #[test]
        fn first_already_uppercase_valid() {
            let original = String::from("First");
            let result = original.first_uppercase();

            assert_eq!("First", result);
        }
    }

    mod parse_id {
        use crate::os::parse_id;

        #[test]
        fn cwe_id_valid_id_parsed() {
            assert_eq!(Some(15), parse_id("CWE-15", "cwe"));
        }

        #[test]
        fn cwe_id_valid_lowercase_id_parsed() {
            assert_eq!(Some(118), parse_id("cwe-118", "cwe"));
        }

        #[test]
        fn cwe_id_invalid_id_not_parsed() {
            assert_eq!(None, parse_id("cwe116", "cwe"));
        }

        #[test]
        fn cwe_id_invalid_id_num_not_parsed() {
            assert_eq!(None, parse_id("CWE-A1", "cwe"));
        }

        #[test]
        fn cwe_id_invalid_id_prefix_not_parsed() {
            assert_eq!(None, parse_id("DFDF-12", "cwe"));
        }

        #[test]
        fn cwe_id_incomplete_id_not_parsed() {
            assert_eq!(None, parse_id("CWE-", "cwe"));
        }

        #[test]
        fn cwe_id_no_separator_not_parsed() {
            assert_eq!(None, parse_id("CWE", "cwe"));
        }
    }

    mod criteria {
        use crate::database::criteria_analysis;
        use utmt::{assert_match_option, assert_not_match_option};

        #[test]
        fn simple_no_error() -> Result<(), &'static str> {
            let args = String::from("Masquerading");
            let result = criteria_analysis(args);

            assert_match_option!(result)
        }

        #[test]
        fn simple_right_content() -> Result<(), &'static str> {
            let args = String::from("Masquerading");
            let result = criteria_analysis(args);

            match result.unwrap().0.contains(&String::from("Masquerading")) {
                true => Ok(()),
                false => Err("Simple criteria analysis failed: content not found"),
            }
        }

        #[test]
        fn analysis_empty_string() -> Result<(), &'static str> {
            let result = criteria_analysis(String::from(""));

            assert_not_match_option!(result)
        }

        #[test]
        fn analysis_only_or_operator() -> Result<(), &'static str> {
            let args = String::from("Masquerading or Hijack");
            let result = criteria_analysis(args);

            assert_match_option!(result)
        }

        #[test]
        fn analysis_or_operator_right_content() -> Result<(), &'static str> {
            let args = String::from("Masquerading or Hijack");
            let result = criteria_analysis(args);

            let mut count = 0;
            result.clone().unwrap().0.iter().for_each(|x| {
                if !x.trim().is_empty() {
                    if x.trim() == "Masquerading" || x.trim() == "Hijack" {
                        count += 1;
                    } else {
                        count -= 1;
                    }
                }
            });

            result.unwrap().1.iter().for_each(|x| {
                if x.trim() == "or" {
                    count += 1;
                } else {
                    count -= 1;
                }
            });

            match count {
                3 => Ok(()),
                _ => Err("Error with or operator"),
            }
        }

        #[test]
        fn analysis_only_and_operator() -> Result<(), &'static str> {
            let args = String::from("Process and Hijacking");
            let result = criteria_analysis(args);

            assert_match_option!(result)
        }

        #[test]
        fn analysis_and_operator_right_content() -> Result<(), &'static str> {
            let args = String::from("Process and Hijacking");
            let result = criteria_analysis(args);

            let mut count = 0;
            result.clone().unwrap().0.iter().for_each(|x| {
                if !x.is_empty() {
                    if x.trim() == "Process" || x.trim() == "Hijacking" {
                        count += 1;
                    } else {
                        count -= 1;
                    }
                }
            });

            result.unwrap().1.iter().for_each(|x| {
                if x.trim() == "and" {
                    count += 1;
                } else {
                    count -= 1;
                }
            });

            match count {
                3 => Ok(()),
                _ => Err("Error with and operator"),
            }
        }

        #[test]
        fn analysis_only_not_operator() -> Result<(), &'static str> {
            let args = String::from("not Masquerading");
            let result = criteria_analysis(args);

            assert_match_option!(result)
        }

        #[test]
        fn analysis_not_operator_right_content() -> Result<(), &'static str> {
            let args = String::from("not Masquerading");
            let result = criteria_analysis(args);

            let mut count = 0;
            result.clone().unwrap().0.iter().for_each(|x| {
                if x.trim() == "Masquerading" || x.trim() == "" {
                    count += 1;
                } else {
                    count -= 1;
                }
            });

            result.unwrap().1.iter().for_each(|x| {
                if x.trim() == "not" {
                    count += 1;
                } else {
                    count -= 1;
                }
            });

            match count {
                3 => Ok(()),
                _ => Err("Error with not operator"),
            }
        }

        #[test]
        fn analysis_with_and_or_operators() -> Result<(), &'static str> {
            let args = String::from("Phishing or Process and Hijacking");
            let result = criteria_analysis(args);

            assert_match_option!(result)
        }

        #[test]
        fn analysis_and_operators_right_content() -> Result<(), &'static str> {
            let args = String::from("Phishing or Process and Hijacking");
            let result = criteria_analysis(args);

            let mut count = 0;
            result.clone().unwrap().0.iter().for_each(|x| {
                if !x.is_empty() {
                    if x.trim() == "Phishing" || x.trim() == "Process" || x.trim() == "Hijacking" {
                        count += 1;
                    } else {
                        count -= 1;
                    }
                }
            });

            result.unwrap().1.iter().for_each(|x| {
                if x.trim() == "and" || x.trim() == "or" {
                    count += 1;
                } else {
                    count -= 1;
                }
            });

            match count {
                5 => Ok(()),
                _ => Err("Error with or/and operators"),
            }
        }

        #[test]
        fn analysis_and_or_not_operators() -> Result<(), &'static str> {
            let args = String::from("Phishing or Process and Hijacking and not Masquerading");
            let result = criteria_analysis(args);

            assert_match_option!(result)
        }

        #[test]
        fn analysis_and_or_not_operators_right_content() -> Result<(), &'static str> {
            let args = String::from("Phishing or Process and Hijacking and not Masquerading");
            let result = criteria_analysis(args);

            let mut count = 0;
            result.clone().unwrap().0.iter().for_each(|x| {
                if !x.trim().is_empty() {
                    if x.trim() == "Phishing"
                        || x.trim() == "Process"
                        || x.trim() == "Hijacking"
                        || x.trim() == "Masquerading"
                    {
                        count += 1;
                    } else {
                        count -= 1;
                    }
                }
            });

            result.unwrap().1.iter().for_each(|x| {
                if x.trim() == "and" || x.trim() == "or" || x.trim() == "not" {
                    count += 1;
                } else {
                    count -= 1;
                }
            });

            match count {
                8 => Ok(()),
                _ => Err("Error with and/or/not operators"),
            }
        }
    }

    mod find_domain {
        use crate::database::find_domain_and_criteria;
        use utmt::{assert_all, assert_match_option, assert_not_match_option};

        #[test]
        fn criteria_simple_no_error() -> Result<(), &'static str> {
            let args = &[String::from("taxonomy = Hijack")];
            let values = find_domain_and_criteria(args);

            assert_match_option!(values)
        }

        #[test]
        fn criteria_simple_with_error() -> Result<(), &'static str> {
            let args = &[String::from("taxonomy")];
            let values = find_domain_and_criteria(args);

            assert_not_match_option!(values)
        }

        #[test]
        fn criteria_simple_valid() {
            let args = &[String::from("taxonomy = Masquerading")];
            let values = find_domain_and_criteria(args);

            let (domain, argument) = values.unwrap();

            assert_all!(domain == "taxonomy", argument == "Masquerading");
        }

        #[test]
        fn criteria_complex() {
            let args = &[String::from(
                "taxonomy = Masquerading and Hijack or impair defense",
            )];
            let values = find_domain_and_criteria(args);
            let (domain, argument) = values.unwrap();

            assert_all!(
                domain == "taxonomy",
                argument == "Masquerading and Hijack or impair defense"
            );
        }

        #[test]
        fn criteria_malformed_error() -> Result<(), &'static str> {
            let args = &[String::from("taxonomy = ")];
            let values = find_domain_and_criteria(args);

            assert_not_match_option!(values)
        }

        #[test]
        fn criteria_malformed_domain_error() -> Result<(), &'static str> {
            let args = &[String::from("= Masquerading ")];
            let values = find_domain_and_criteria(args);

            assert_not_match_option!(
                values,
                "The malformed expression ' = Masquerading ' would be invalid"
            )
        }

        #[test]
        fn criteria_malformed_equal_only_error() -> Result<(), &'static str> {
            let args = &[String::from("=")];
            let values = find_domain_and_criteria(args);

            assert_not_match_option!(values, "'=' alone would not be supported")
        }

        #[test]
        fn criteria_malformed_triple_equals_error() -> Result<(), &'static str> {
            let args = &[String::from("===")];
            let values = find_domain_and_criteria(args);

            assert_not_match_option!(values, "'===' would not be supported")
        }
    }

    mod mitre {
        use crate::database::find_mitre_by_id;

        #[test]
        fn find_mitre_id() -> Result<(), &'static str> {
            if let Some(_) = find_mitre_by_id("1562.003") {
                Ok(())
            } else {
                Err("Mitre data not found")
            }
        }

        #[test]
        fn find_invalid_mitre_id() -> Result<(), &'static str> {
            if let Some(_) = find_mitre_by_id("") {
                Err("Mitre data would be not found")
            } else {
                Ok(())
            }
        }
    }
}