//! The crate responsible for executing the core work of `Zork++`,

//! generate command lines and execute them in a shell of the current

//! operating system against the designed compilers in the configuration

//! file.

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

use std::path::Path;

use color_eyre::Result;

use crate::domain::commands::arguments::Argument;

use crate::domain::flyweight_data::FlyweightData;

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

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

use crate::project_model::modules::SystemModule;

use crate::project_model::target::TargetModel;

use crate::utils::constants::error_messages;

use crate::{

    cache::ZorkCache,

    domain::translation_unit::{TranslationUnit, TranslationUnitKind},

    project_model::{

        compiler::{CppCompiler, StdLibMode},

        modules::{ModuleImplementationModel, ModuleInterfaceModel},

        sourceset::SourceFile,

        ZorkModel,

    },

    utils::constants,

};

/// The core procedure. Generates the commands arguments that will be sent to the compiler

/// for every translation unit declared by the user for its project

    model: &'a ZorkModel<'a>,

    cache: &mut ZorkCache<'a>,

) -> Result<()> {

    // Load the flyweight arguments (repeated args across all the source command lines)

    }

    // Build the std library as a module

    // System headers as modules

    }

    // Generates commands for the modules

    // Translation units and linker

    // Generate commands for the declared targets

/// Generates the cmds for build the C++ standard libraries (std and std.compat) according to the specification

/// of each compiler vendor

        CppCompiler::CLANG => {

            }

        }

        CppCompiler::MSVC => {

        }

        _ => (),

    }

/// Procedure to generate the commands for the system headers of their standard C++ library

/// for a given compiler

///

/// These commands are the ones that allows to translate C++ standard headers to named modules

    model: &'a ZorkModel<'a>,

    cache: &mut ZorkCache<'a>,

) -> Result<()> {

        model,

        cache,

    )

/// The procedure that takes care of generating the [`SourceCommandLine`] to build the user's declared

/// C++ standard names modules

        model,

        cache,

    )

        model,

        cache,

    )

        .targets

        .iter()

    {

        // 1st - Generate the commands for the non-module sources

        // 2nd - Generate the linker command for the 'target' declared by the user

    }

/// Processor for generate the commands of the non-modular translation units

///

/// *NOTE*: This will be changed on the future, when we decide how we should architecture the implementation

/// of named targets

///

/// *IMPL_NOTE*: Consider in the future if it's worth to maintain two paths for build module implementations

/// and source, since they are basically (almost) the same thing

    model: &'a ZorkModel<'a>,

    cache: &mut ZorkCache<'a>,

    target: (&'a TargetIdentifier<'a>, &'a TargetModel<'a>),

) -> Result<()> {

        "Generating the commands for the source files of target: {:?}",

        target_identifier.name()

    );

        model,

        cache,

        // names

    )

/// Generates the command line that will be passed to the linker to generate an target final product

    model: &'a ZorkModel<'_>,

    cache: &mut ZorkCache<'a>,

    target: (&'a TargetIdentifier<'a>, &'a TargetModel<'a>),

) -> Result<()> {

        "Generating the linker command line for target: {:?}",

        &target.0.name()

    );

        .generated_commands

        .targets

        .get_mut(target_identifier)

        .linker;

            .with_extension(constants::BINARY_EXTENSION),

    // Check if its necessary to change the target output details

        };

    }

    // Check if the extra args passed by the user to the linker has changed from previous

    // iterations

            .extra_args

    }

/// The core procedure of the commands generation process.

///

/// It takes care of generate the [`SourceCommandLine`] for a set of given implementors of [`TranslationUnit`],

/// processing them according to the passed [`TranslationUnitKind`] discriminator if the command doesn't exist,

/// otherwise, it will handle the need of tracking individually every translation unit in every program iteration

/// (while the cache isn't purged by the user) to set their [`TranslationUnitStatus`] flag, which ultimately

/// decides on every run if the file must be sent to build to the target [`CppCompiler`]

    model: &'a ZorkModel<'a>,

    cache: &mut ZorkCache<'a>,

    translation_units: &'a [T],

    for_kind: TranslationUnitKind<'a>,

) -> Result<()> {

    }

    model: &'a ZorkModel<'a>,

    cache: &mut ZorkCache<'a>,

    translation_unit: &'a T,

    for_kind: &TranslationUnitKind<'a>,

) -> Result<()> {

    {

        let build_translation_unit =

        }

    } else {

            TranslationUnitKind::ModuleInterface => {

                let resolved_tu =

            }

            TranslationUnitKind::ModuleImplementation => {

                    tu_with_erased_type,

                )

            }

                let resolved_tu =

            }

            TranslationUnitKind::SystemHeader => {

                let resolved_tu =

            }

            _ => (),

        }

    };

/// Command line arguments generators procedures for C++ standard modules

mod modules {

    use std::path::{Path, PathBuf};

    use crate::cache::ZorkCache;

    use crate::compiler::helpers;

    use crate::compiler::helpers::generate_bmi_file_path;

    use crate::domain::commands::arguments::{clang_args, msvc_args, Arguments};

    use crate::domain::commands::command_lines::SourceCommandLine;

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

    use crate::project_model::compiler::{CppCompiler, StdLibMode};

    use crate::project_model::modules::{

        ModuleImplementationModel, ModuleInterfaceModel, SystemModule,

    };

    use crate::project_model::ZorkModel;

    use crate::utils::constants::dir_names;

    /// Generates the expected arguments for precompile the BMIs depending on self

        model: &'a ZorkModel<'a>,

        cache: &mut ZorkCache<'a>,

        interface: &'a ModuleInterfaceModel<'a>,

    ) {

        // The Path of the generated binary module interface

        let binary_module_ifc =

            CppCompiler::CLANG => {

                    out_dir,

                ));

                // The generated BMI

            }

            CppCompiler::MSVC => {

                    .join(dir_names::MODULES)

                // The output .obj file

                    } else {

                    }

                } else {

                }

            }

            CppCompiler::GCC => {

                // The output file

            }

        }

        // The input file

    /// Generates the required arguments for compile the implementation module files

        model: &'a ZorkModel<'a>,

        cache: &mut ZorkCache<'a>,

        implementation: &'a ModuleImplementationModel<'a>,

    ) {

        // The input file

            CppCompiler::CLANG => {

                // The resultant object file

                    out_dir,

                ));

            }

            CppCompiler::MSVC => {

                // The output .obj file

            }

            CppCompiler::GCC => {

                // The output file

            }

        }

    /// System headers can be imported as modules, but they must be built before being imported.

    ///

    /// This feature is supported by `GCC` and `Clang`

        model: &'a ZorkModel<'a>,

        cache: &mut ZorkCache<'a>,

        sys_module: &'a SystemModule<'a>,

    ) {

        );

            CppCompiler::CLANG => {

            }

            CppCompiler::GCC => {

                // `GCC` system headers built as modules goes directly to their `gcm.cache`

            }

            _ => {}

        };

            // system headers

        };

        model: &'a ZorkModel<'a>,

        cache: &mut ZorkCache<'a>,

        stdlib_mode: StdLibMode,

    ) {

                .is_none()

        {

                "Generating the command for build the {:?} {}",

                compiler,

                stdlib_mode.printable_info()

            );

            };

        }

}

/// Specific operations over source files

mod sources {

    use crate::cache::ZorkCache;

    use crate::domain::commands::arguments::Arguments;

    use crate::domain::commands::command_lines::SourceCommandLine;

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

    use crate::domain::translation_unit::TranslationUnit;

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

    use crate::project_model::{compiler::CppCompiler, ZorkModel};

    use crate::utils::constants::error_messages;

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

    use super::helpers;

    /// Generates the command line arguments for non-module source files

        model: &'a ZorkModel<'a>,

        cache: &mut ZorkCache<'a>,

        source: &'a SourceFile<'a>,

        target_identifier: &TargetIdentifier<'a>,

    ) -> Result<()> {

            CppCompiler::CLANG | CppCompiler::GCC => {

            }

        }

            .generated_commands

            .targets

            .get_mut(target_identifier)

                    "{}: {:?}",

                    error_messages::TARGET_ENTRY_NOT_FOUND,

                    target_identifier

                )

            .sources

}

/// Helpers for reduce the cyclomatic complexity of generating command lines, arguments

/// and in other cases, paths depending on what kind of [`TranslationUnitKind`] we are

/// processing

///

/// This module is actually public(crate) reexported since we need to

pub(crate) mod helpers {

    use super::*;

    use crate::domain::commands::command_lines::SourceCommandLine;

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

    use crate::utils::constants::dir_names;

    use chrono::{DateTime, Utc};

    use std::path::PathBuf;

    /// Creates the path for a prebuilt module interface, based on the default expected

    /// extension for BMI's given a compiler

        compiler: CppCompiler,

        out_dir: &Path,

        interface: &ModuleInterfaceModel,

    ) -> PathBuf {

            } else {

            }

        } else {

        }

    /// Generates the [`PathBuf`] of the resultant binary module interface file of a C++ module interface

        out_dir: &Path,

        compiler: CppCompiler,

        module_name: &str,

    ) -> PathBuf {

        } else {

        };

    /// Generates the [`PathBuf`] of the resultant `.obj` file of a [`TranslationUnit`] where the

    /// `.obj` file is one of the byproducts of the build process (and the one that will be sent

    /// to the linker)

        compiler: CppCompiler,

        out_dir: &Path,

        implementation: &T,

    ) -> PathBuf {

            .join(dir_names::OBJECT_FILES)

    /// Template factory function to call the inspectors of the status of a file on the fs that

    /// is represented within `Zork++` as some kind of [`TranslationUnit`] and the status flags

    /// tracked on the entities like [`SourceCommandLine::status`] and others from the [`ZorkCache`]

    /// as well to determine when a concrete user declared file must be sent to the compiler in order

    /// to be built, or we can skip it

    ///

    /// *returns: <[`TranslationUnitStatus`]>* - The state that should be set to the current

    /// [`SourceCommandLine`] in order to be handled

        last_process_execution: &DateTime<Utc>,

        cached_source_cmd: &SourceCommandLine,

    ) -> TranslationUnitStatus {

        // In case the user deleted the translation unit from the fs but not from the Zork++ cfg file

        }

        // In case the file suffered changes

        let need_to_build =

        } else {

        }

    /// Checks whenever a [`TranslationUnit`] has been modified on the filesystem and its changes

    /// was made *after* the last time that `Zork++` made a run.

    ///

    /// *returns: <bool>* - true if the target [`TranslationUnit`] has been modified after the last

    /// iteration, false otherwise

        last_process_execution: &DateTime<Utc>,

        cached_source_cmd: &SourceCommandLine,

    ) -> bool {

        // If exists and was successful, let's see if has been modified after the program last iteration

            },

        }

    /// Determines which kind of [`TranslationUnitStatus`] variant must a [`SourceCommandLine`]

    /// have on every process regarding specific checks and conditions before and after sent to

    /// build

        scl: &SourceCommandLine,

    ) -> TranslationUnitStatus {

            TranslationUnitStatus::Success | TranslationUnitStatus::Cached => {

            }

        }

            "{}: {:?}",

            error_messages::WRONG_DOWNCAST_FOR,

        )

}