//! The implementation of the Zork++ cache, for persisting data in between process

pub mod compile_commands;

use chrono::{DateTime, Utc};

use color_eyre::{eyre::Context, Result};

use std::collections::HashMap;

use std::fmt::Debug;

use std::{

    fs::File,

    path::{Path, PathBuf},

    time::Instant,

};

use crate::config_file::ZorkConfigFile;

use crate::domain::commands::command_lines::{Commands, SourceCommandLine};

use crate::domain::target::TargetIdentifier;

use crate::domain::translation_unit::{TranslationUnit, TranslationUnitKind};

use crate::project_model::sourceset::SourceFile;

use crate::utils::constants::{dir_names, error_messages};

use crate::{

    cli::input::CliArgs,

    project_model,

    project_model::{compiler::CppCompiler, ZorkModel},

    utils::{self},

};

use serde::{Deserialize, Serialize};

use crate::project_model::compiler::StdLibMode;

use crate::utils::constants;

/// Standalone utility for load from the file system the Zork++ cache file

/// for the target [`CppCompiler`]

    config: &ZorkConfigFile<'a>,

    cli_args: &CliArgs,

    project_root: &Path,

) -> Result<ZorkCache<'a>> {

            .build

            .as_ref()

            .unwrap_or(dir_names::DEFAULT_OUTPUT_DIR),

    );

    } else {

            "Loading Zork++ cache file for {compiler} at: {:?}",

            cache_file_path

        );

    };

pub struct ZorkCache<'a> {

}

impl<'a> ZorkCache<'a> {

        &mut self,

        translation_unit: &T,

        translation_unit_kind: &TranslationUnitKind<'a>,

    ) -> Option<&mut SourceCommandLine<'a>> {

            }

            },

        }

        &mut self,

        module_interface: &T,

    ) -> Option<&mut SourceCommandLine<'a>> {

            .modules

            .interfaces

            .iter_mut()

        &mut self,

        module_impl: &T,

    ) -> Option<&mut SourceCommandLine<'a>> {

            .modules

            .implementations

            .iter_mut()

        &mut self,

        source: &T,

        for_target: &TargetIdentifier<'a>,

    ) -> Option<&mut SourceCommandLine<'a>> {

            .targets

            .get_mut(for_target)

                    .sources

                    .iter_mut()

    /// Gets the target [`SystemModule`] generated [`SourceCommandLine`] from the cache

    ///

    /// NOTE: While we don't implement the lookup of the directory of the installed system headers,

    /// we are using some tricks to matching the generated command, but is not robust

        &mut self,

        system_module: &T,

    ) -> Option<&mut SourceCommandLine<'a>> {

            .modules

            .system_modules

            .iter_mut()

        &mut self,

        stdlib_mode: StdLibMode,

    ) -> Option<&mut SourceCommandLine<'a>> {

        }

        &mut self,

        stdlib_mode: StdLibMode,

        cmd_line: Option<SourceCommandLine<'a>>,

    ) {

        }

    /// The tasks associated with the cache after load it from the file system

        if cfg!(target_os = "windows") && compiler.eq(&CppCompiler::MSVC) {

            msvc::load_metadata(self, program_data)?

        }

    /// Runs the tasks just before end the program and save the cache

        }

                "Zork++ took a total of {:?} ms on generate the compilation database",

                compile_commands_time.elapsed().as_millis()

            );

        }

    /// Method that returns the HashMap that holds the environmental variables that must be passed

    /// to the underlying shell

    #[inline(always)]

    pub fn get_process_env_args(&'a mut self, compiler: CppCompiler) -> &'a EnvVars {

        match compiler {

            CppCompiler::MSVC => &self.compilers_metadata.msvc.env_vars,

            CppCompiler::CLANG => &self.compilers_metadata.clang.env_vars,

            CppCompiler::GCC => &self.compilers_metadata.gcc.env_vars,

        }

    }

    /// Returns a view of borrowed data over all the generated commands for a target

    // TODO: guess that this method is not being used, due to the &self parameter, which provokes

    // lots of lifetime issues on the codebase. Remove it.

            .modules

            .cpp_stdlib

            .as_slice()

            .iter()

            .chain(

                    .targets

                    .values()

            )

    /// The current integer value that is the total of commands generated for all the

    /// [`TranslationUnit`] declared in the user's configuration file, without counting the linker

    /// one for the current target

            + 2 // the cpp_stdlib and the c_compat_stdlib

}

/// A struct for holding Zork++ internal details about its configuration, procedures or runtime

/// statuses

pub struct CacheMetadata {

    // Internal helpers

    #[serde(skip)]

    #[serde(skip)]

}

/// Type alias for the underlying key-value based collection of environmental variables

pub type EnvVars = HashMap<String, String>;

pub struct CompilersMetadata<'a> {

    // TODO: shouldn't this be an Enum or a fat pointer?

}

pub struct MsvcMetadata<'a> {

    // the user

    // Same as the ones defined for the C++ std lib, but for the C std lib

    // The environmental variables that will be injected to the underlying invoking shell

                           // since every Cache entity is already unique per compilation process?

}

pub struct ClangMetadata {

}

pub struct GccMetadata {

}

/// Helper procedures to process cache data for Microsoft's MSVC

mod clang {

    use color_eyre::eyre::{self, Context, ContextCompat, Result};

    use regex::Regex;

    use std::{ffi::OsStr, path::Path, time::Instant};

    use walkdir::WalkDir;

    use super::{ClangMetadata, ZorkCache};

    use crate::{project_model::ZorkModel, utils::constants::error_messages};

        cache: &mut ZorkCache,

        program_data: &ZorkModel,

    ) -> color_eyre::Result<()> {

        }

        // TODO: if the driver changes on the cfg, how do we know that we have to process this

        // cached information again? Just because cache and model are rebuilt again? Can't recall it

            .arg("-###")

            .output()

        // Combine stdout and stderr into a single output string

        // Typically, the useful information will be in stderr for `clang++ -###` commands

        }

        } else {

        }

        // Byproducts

            .join("clang")

            .join("modules")

            .join("std")

            .join("std")

            .join("clang")

            .join("modules")

            .join("std") // Folder

            .join("std") // Partial filename

            .with_extension(

                        .compiler

                        .cpp_compiler

                        .get_typical_bmi_extension(),

        user_libcpp_declared_location: &Path,

        cache: &mut ZorkCache,

    ) -> Result<()> {

                "Found the declared LIBC++ installation at: {:?}",

                user_libcpp_path

            );

        } else {

        }

            "No libc++ installation path was provided. Trying to find one in the system with the standard modules..\

            \nThis may take a while..."

        );

        let assumed_root = if cfg!(target_os = "windows") {

            "C:/" // TODO: should we return an Err and force the user to mandatory

                  // provide an installation?

        } else {

        };

        // TODO: maybe we could add some assumed default 'BIG paths' instead of just one

            .into_iter()

            .filter_map(Result::ok)

        {

                            "Found a valid LIBC++ installation with std.cppm at: {:?}. Took: {:?}",

                            libcpp_path,

                            start.elapsed()

                        );

                    }

            error_messages::clang::MISSING_LIBCPP_INSTALLATION

        ))

            }

        }

        } else {

        }

    /// Helper for extract metainformation about the declared version of the clang's invoked driver

        // Regex pattern to match the version number

        // Apply the regex to the output string

        // Return the captured version number

            .get(1)

            .first()

            .get(1)

            .get(2)

    /// Helper for extract metainformation about the installed dir of the clang's invoked driver

            .collect::<Vec<&str>>()

            .get(1)

    #[cfg(test)]

    mod tests {

        #[test]

                expected,

            );

                expected,

            );

                expected,

            )

        #[test]

                expected,

            );

    }

}

/// Helper procedures to process cache data for Microsoft's MSVC

mod msvc {

    use crate::cache::ZorkCache;

    use crate::project_model::sourceset::SourceFile;

    use crate::project_model::ZorkModel;

    use crate::utils;

    use crate::utils::constants::{self, dir_names};

    use crate::utils::constants::{env_vars, error_messages};

    use color_eyre::eyre::{eyre, Context, ContextCompat, OptionExt};

    use regex::Regex;

    use std::borrow::Cow;

    use std::collections::HashMap;

    use std::path::Path;

    /// If *Windows* is the current OS, and the compiler is *MSVC*, then we will try

    /// to locate the path of the `vcvars64.bat` script that will set a set of environmental

    /// variables that are required to work effortlessly with the Microsoft's compiler.

    ///

    /// After such effort, we will dump those env vars to a custom temporary file where every

    /// env var is registered there in a key-value format, so we can load it into the cache and

    /// run this process once per new cache created (cache action 1)

        cache: &mut ZorkCache,

        program_data: &ZorkModel,

    ) -> color_eyre::Result<()> {

                constants::MS_ENV_VARS_BAT,

            )

                    constants::MSVC_REGULAR_BASE_PATH,

                    constants::MSVC_REGULAR_BASE_SCAPED_PATH,

                )

                .arg("/c")

                    error_messages::msvc::MISSING_OR_CORRUPTED_MSVC_DEV_COMMAND_PROMPT,

                .arg("&&")

                .arg("set")

                .output()

            // Cloning the useful ones for quick access at call site

            // Check the existence of the VCtools

                .env_vars

                .get(env_vars::VC_TOOLS_INSTALL_DIR)

            }

            };

            };

                .join(dir_names::MODULES)

                .join(dir_names::STD) // folder

            // Saving the paths to the precompiled bmi and obj files of the MSVC std implementation

            // that will be used to reference the build of the std as a module

    /// Convenient helper to manipulate and store the environmental variables as result of invoking

    /// the Windows `SET` cmd command

            // Parse the key-value pair from each line

                .next()

                .expect(error_messages::msvc::ILL_FORMED_KEY_ON_ENV_VARS_PARSING)

                .trim();

            }

        }

}

pub(crate) mod helpers {

    use color_eyre::eyre::ContextCompat;

    use self::utils::constants::error_messages;

    use super::*;

    use crate::domain::translation_unit::TranslationUnitStatus;

    use std::path::PathBuf;

        cache_path: PathBuf,

        cache_file_path: PathBuf,

        compiler: CppCompiler,

    ) -> Result<ZorkCache<'a>> {

        cache_path: PathBuf,

        cache_file_path: PathBuf,

        compiler: CppCompiler,

    ) -> Result<ZorkCache<'a>> {

                cache_file_path,

                project_model_file_path,

            },

        // clean the user compilation products

        // restore to default some of the metadata properties

    /// Checks for those translation units that the process detected that must be deleted from the

    /// cache -> [`TranslationUnitStatus::ToDelete`] or if the file has been removed from the

    /// Zork++ configuration file or if it has been removed from the fs

    ///

    /// Can we only call this when we know that the user modified the ZorkCache file for the current iteration?

        cache: &mut ZorkCache,

        program_data: &ZorkModel<'_>,

    ) -> Result<bool> {

        ) || {

                    &mut target_data.sources,

                        .targets

                        .get(target_name)

                        .sources

                        .as_slice(),

                );

                }

            }

        } || remove_if_needed_from_cache_and_count_changes(

            &mut cache.generated_commands.modules.system_modules,

            &program_data.modules.sys_modules,

        );

        cached_commands: &mut Vec<SourceCommandLine>,

        user_declared_translation_units: &[T],

    ) -> bool {

                    .iter()

                }

            }

}