// SPDX-License-Identifier: MPL-2.0
#ifndef VYBUILD_LIB_H
#define VYBUILD_LIB_H
#include <string>
#include <fstream>
#include <filesystem>
#include <iostream>
#include <variant>
#include <vector>
#include <unistd.h>
#include <limits.h>
#include "json.hpp"
#include "xxhash.h"
#include <uuid/uuid.h>
using json=nlohmann::json;
namespace fs=std::filesystem;
const std::string syntax_version="0.1";
const std::vector<std::string> threaded_actions={"run_submodule","run_submodule_if","run_actions_parallel","vyld_compilation","run_submodule_parallel","compile_multiple_cpp"};
namespace vybuild {
  namespace fat32 {
    void load_crypto_lib(std::string path);
    bool is_crypto_lib_loaded();
    bool is_vftm_target_set();
    uint8_t* get_manifest_keypair_buffer();
    void create_fat32(std::string key,size_t size);
    void add_directory_fat32(std::string key,std::string full_path);
    void add_file_fat32(std::string key,std::string full_path,uint8_t *buffer_in,size_t file_size,bool is_vftm_target);
    std::vector<uint8_t> export_fat32(std::string key,bool generate_vftm,std::string disk_guid_var,std::string efi_part_unique_guid_var);
  }
  namespace disk {
    std::array<uint8_t,16> uuid4_to_bytes(const std::string& uuid);
    void create_disk(std::string key,size_t size,std::string disk_guid);
    void add_partition(std::string key,size_t partition_size_bytes,std::string type_guid,std::string unique_guid,uint64_t attributes,std::string name,uint8_t* in_buf,size_t in_size);
    std::vector<uint8_t> export_disk(std::string key);
  }
  namespace condition {
    bool evaluate_condition(const json& condition);
  }
  namespace parser {
    std::string root_folder_parsing(const std::string& root_folder,const std::string& file);
    std::vector<std::string> vector_string_vars(std::vector<std::string> vector_in);
    std::string string_vars(std::string string_in);
    std::vector<std::string> vector_string_path_completions(std::vector<std::string> vector_in,std::string suffix);
  }
  namespace vars {
    std::vector<std::string>& get_global_variables_list();
    void set_global_variable(std::string key,std::string value);
    std::string get_global_variable(std::string key);
  }
  namespace cache {
    void init_cache(bool enable_smart_cache);
    void store_file(std::string key,fs::path file_path);
    bool cache_contains(std::string key);
    void extract_file(std::string key,fs::path output_path);
    void clean_cache();
    std::string xxhash_to_string(XXH128_hash_t hash);
  }
  namespace actions {
    void check_arg_string(const json& args,std::string field_name);
    void check_arg_vector_string(const json& args,std::string field_name);
    enum class ActionStatus {
      Success,
      Fail,
      SystemError,
      ExitSuccess,
      ExitFail
    };
    class RunSubmoduleAction {
      public:
        RunSubmoduleAction(const json& args,std::string root_folder) {
          char path[PATH_MAX];
          getcwd(path,sizeof(path));
          chdir(root_folder.c_str());
          check_arg_string(args,"file");
          if (!args.contains("wait")) throw std::runtime_error("Wait isn't provided.");
          if (!args["wait"].is_boolean()) throw std::runtime_error("Wait isn't a boolean");
          if (!args.contains("block_if_fail")) throw std::runtime_error("Block if fail isn't provided.");
          if (!args["block_if_fail"].is_boolean()) throw std::runtime_error("Block if fail isn't a boolean");
          this->file_variables=args["file_variables"].get<bool>();
          this->file=args["file"].get<std::string>();
          this->wait=args["wait"].get<bool>();
          this->block_if_fail=args["block_if_fail"].get<bool>();
          chdir(path);
        }
        bool file_variables;
        std::string file;
        bool wait;
        bool block_if_fail;
        ActionStatus run_action();
    };
    class RunCommandWaitAction {
      public:
        RunCommandWaitAction(const json& args) {
          check_arg_vector_string(args,"command");
          if (!args.contains("show_output")) throw std::runtime_error("Show output isn't provided.");
          if (!args["show_output"].is_string()) throw std::runtime_error("Show output isn't a string");
          if (args["show_output"]!="live" && args["show_output"]!="on_failure" && args["show_output"]!="silent") {
            throw std::runtime_error("\""+args["show_output"].get<std::string>()+"\" isn't a valid output mode.");
          }
          if (!args.contains("success_status")) throw std::runtime_error("Success status isn't provided.");
          if (!args["success_status"].is_array()) throw std::runtime_error("Success status isn't a boolean");
          for (auto& arg:args["success_status"]) {
            if (!arg.is_number_integer()) throw std::runtime_error("One of the status code isn't an integer.");
          }
          if (!args.contains("ignore_success_status")) throw std::runtime_error("Ignore success status isn't provided.");
          if (!args["ignore_success_status"].is_boolean()) throw std::runtime_error("Ignore success status isn't a boolean");
          this->command_variables=args["command_variables"].get<bool>();
          this->command=args["command"].get<std::vector<std::string>>();
          this->show_output=args["show_output"].get<std::string>();
          this->success_status=args["success_status"].get<std::vector<int>>();
          this->ignore_success_status=args["ignore_success_status"].get<bool>();
        }
        bool command_variables;
        std::vector<std::string> command;
        std::string show_output;
        std::vector<int> success_status;
        bool ignore_success_status;
        ActionStatus run_action();
    };
    class SaveCommandContentAction {
      public:
        SaveCommandContentAction(const json& args) {
          check_arg_vector_string(args,"command");
          if (!args.contains("success_status")) throw std::runtime_error("Success status isn't provided.");
          if (!args["success_status"].is_array()) throw std::runtime_error("Success status isn't a boolean");
          for (auto& arg:args["success_status"]) {
            if (!arg.is_number_integer()) throw std::runtime_error("One of the status code isn't an integer.");
          }
          if (!args.contains("ignore_success_status")) throw std::runtime_error("Ignore success status isn't provided.");
          if (!args["ignore_success_status"].is_boolean()) throw std::runtime_error("Ignore success status isn't a boolean");
          check_arg_string(args,"command_output_file");
          this->command_variables=args["command_variables"].get<bool>();
          this->command=args["command"].get<std::vector<std::string>>();
          this->success_status=args["success_status"].get<std::vector<int>>();
          this->ignore_success_status=args["ignore_success_status"].get<bool>();
          this->command_output_file_variables=args["command_output_file_variables"].get<bool>();
          this->command_output_file=args["command_output_file"].get<std::string>();
        }
        bool command_variables;
        std::vector<std::string> command;
        std::vector<int> success_status;
        bool ignore_success_status;
        bool command_output_file_variables;
        std::string command_output_file;
        ActionStatus run_action();
    };
    class CompileOneAsmAction {
      public:
        CompileOneAsmAction(const json& args) {
          check_arg_string(args,"source");
          check_arg_string(args,"assembler");
          check_arg_vector_string(args,"pre_arguments");
          check_arg_vector_string(args,"post_arguments");
          check_arg_string(args,"output_file");
          if (!args.contains("success_status")) throw std::runtime_error("Success status isn't provided.");
          if (!args["success_status"].is_array()) throw std::runtime_error("Success status isn't a boolean");
          for (auto& arg:args["success_status"]) {
            if (!arg.is_number_integer()) throw std::runtime_error("One of the status code isn't an integer.");
          }
          if (!args.contains("ignore_success_status")) throw std::runtime_error("Ignore success status isn't provided.");
          if (!args["ignore_success_status"].is_boolean()) throw std::runtime_error("Ignore success status isn't a boolean");
          if (!args.contains("cache_authorized")) throw std::runtime_error("Cache authorized isn't provided.");
          if (!args["cache_authorized"].is_boolean()) throw std::runtime_error("Cache authorized isn't a boolean");
          this->source_variables=args["source_variables"].get<bool>();
          this->assembler_variables=args["assembler_variables"].get<bool>();
          this->pre_arguments_variables=args["pre_arguments_variables"].get<bool>();
          this->post_arguments_variables=args["post_arguments_variables"].get<bool>();
          this->output_file_variables=args["output_file_variables"].get<bool>();
          this->source=args["source"].get<std::string>();
          this->assembler=args["assembler"].get<std::string>();
          this->output_file=args["output_file"].get<std::string>();
          this->pre_arguments=args["pre_arguments"].get<std::vector<std::string>>();
          this->post_arguments=args["post_arguments"].get<std::vector<std::string>>();
          this->success_status=args["success_status"].get<std::vector<int>>();
          this->ignore_success_status=args["ignore_success_status"].get<bool>();
          this->cache_authorized=args["cache_authorized"].get<bool>();
        }
        bool source_variables;
        std::string source;
        bool assembler_variables;
        std::string assembler;
        bool pre_arguments_variables;
        std::vector<std::string> pre_arguments;
        bool post_arguments_variables;
        std::vector<std::string> post_arguments;
        bool output_file_variables;
        std::string output_file;
        std::vector<int> success_status;
        bool ignore_success_status;
        bool cache_authorized;
        ActionStatus run_action();
    };
    class EnsureFolderExistenceAction {
      public:
        EnsureFolderExistenceAction(const json& args) {
          check_arg_string(args,"path");
          this->path_variables=args["path_variables"].get<bool>();
          this->path=args["path"].get<std::string>();
        }
        bool path_variables;
        std::string path;
        ActionStatus run_action();
    };
    class MoveFileAction {
      public:
        MoveFileAction(const json& args) {
          check_arg_string(args,"source_file");
          check_arg_string(args,"destination_folder");
          this->source_file_variables=args["source_file_variables"].get<bool>();
          this->source_file=args["source_file"].get<std::string>();
          this->destination_folder_variables=args["destination_folder_variables"].get<bool>();
          this->destination_folder=args["destination_folder"].get<std::string>();
        }
        bool source_file_variables;
        std::string source_file;
        bool destination_folder_variables;
        std::string destination_folder;
        ActionStatus run_action();
    };
    class CompileOneCppAction {
      public:
        CompileOneCppAction(const json& args) {
          check_arg_string(args,"source");
          check_arg_string(args,"compiler");
          check_arg_vector_string(args,"pre_arguments");
          check_arg_vector_string(args,"post_arguments");
          check_arg_string(args,"output_file");
          check_arg_string(args,"headers_command");
          if (!args.contains("success_status")) throw std::runtime_error("Success status isn't provided.");
          if (!args["success_status"].is_array()) throw std::runtime_error("Success status isn't a boolean");
          for (auto& arg:args["success_status"]) {
            if (!arg.is_number_integer()) throw std::runtime_error("One of the status code isn't an integer.");
          }
          if (!args.contains("ignore_success_status")) throw std::runtime_error("Ignore success status isn't provided.");
          if (!args["ignore_success_status"].is_boolean()) throw std::runtime_error("Ignore success status isn't a boolean");
          if (!args.contains("cache_authorized")) throw std::runtime_error("Cache authorized isn't provided.");
          if (!args["cache_authorized"].is_boolean()) throw std::runtime_error("Cache authorized isn't a boolean");
          this->source_variables=args["source_variables"].get<bool>();
          this->compiler_variables=args["compiler_variables"].get<bool>();
          this->pre_arguments_variables=args["pre_arguments_variables"].get<bool>();
          this->post_arguments_variables=args["post_arguments_variables"].get<bool>();
          this->output_file_variables=args["output_file_variables"].get<bool>();
          this->headers_command_variables=args["headers_command_variables"].get<bool>();
          this->source=args["source"].get<std::string>();
          this->compiler=args["compiler"].get<std::string>();
          this->output_file=args["output_file"].get<std::string>();
          this->pre_arguments=args["pre_arguments"].get<std::vector<std::string>>();
          this->post_arguments=args["post_arguments"].get<std::vector<std::string>>();
          this->success_status=args["success_status"].get<std::vector<int>>();
          this->ignore_success_status=args["ignore_success_status"].get<bool>();
          this->cache_authorized=args["cache_authorized"].get<bool>();
          this->headers_command=args["headers_command"].get<std::string>();
        }
        bool source_variables;
        std::string source;
        bool compiler_variables;
        std::string compiler;
        bool pre_arguments_variables;
        std::vector<std::string> pre_arguments;
        bool post_arguments_variables;
        std::vector<std::string> post_arguments;
        bool output_file_variables;
        std::string output_file;
        std::vector<int> success_status;
        bool ignore_success_status;
        bool cache_authorized;
        bool headers_command_variables;
        std::string headers_command;
        ActionStatus run_action();
    };
    class RunSubmoduleIfAction {
      public:
        RunSubmoduleIfAction(const json& args,std::string root_folder) {
          char path[PATH_MAX];
          getcwd(path,sizeof(path));
          chdir(root_folder.c_str());
          check_arg_string(args,"file");
          if (!args.contains("wait")) throw std::runtime_error("Wait isn't provided.");
          if (!args["wait"].is_boolean()) throw std::runtime_error("Wait isn't a boolean");
          if (!args.contains("block_if_fail")) throw std::runtime_error("Block if fail isn't provided.");
          if (!args["block_if_fail"].is_boolean()) throw std::runtime_error("Block if fail isn't a boolean");
          if (!args.contains("condition")) throw std::runtime_error("Condition isn't provided.");
          if (!args["condition"].is_object()) throw std::runtime_error("Condition isn't a dictionnary.");
          this->condition=args["condition"];
          this->file=args["file"].get<std::string>();
          this->file=fs::absolute(fs::path(args["file"].get<std::string>()));
          this->wait=args["wait"].get<bool>();
          this->block_if_fail=args["block_if_fail"].get<bool>();
          chdir(path);
        }
        json condition;
        bool file_variables;
        std::string file;
        bool wait;
        bool block_if_fail;
        ActionStatus run_action();
    };
    class RunCommandWaitDirAction {
      public:
        RunCommandWaitDirAction(const json& args) {
          check_arg_vector_string(args,"command");
          check_arg_string(args,"working_dir");
          if (!args.contains("show_output")) throw std::runtime_error("Show output isn't provided.");
          if (!args["show_output"].is_string()) throw std::runtime_error("Show output isn't a string");
          if (args["show_output"]!="live" && args["show_output"]!="on_failure" && args["show_output"]!="silent") {
            throw std::runtime_error("\""+args["show_output"].get<std::string>()+"\" isn't a valid output mode.");
          }
          if (!args.contains("success_status")) throw std::runtime_error("Success status isn't provided.");
          if (!args["success_status"].is_array()) throw std::runtime_error("Success status isn't a boolean");
          for (auto& arg:args["success_status"]) {
            if (!arg.is_number_integer()) throw std::runtime_error("One of the status code isn't an integer.");
          }
          if (!args.contains("ignore_success_status")) throw std::runtime_error("Ignore success status isn't provided.");
          if (!args["ignore_success_status"].is_boolean()) throw std::runtime_error("Ignore success status isn't a boolean");
          this->command_variables=args["command_variables"].get<bool>();
          this->command=args["command"].get<std::vector<std::string>>();
          this->show_output=args["show_output"].get<std::string>();
          this->success_status=args["success_status"].get<std::vector<int>>();
          this->ignore_success_status=args["ignore_success_status"].get<bool>();
          this->working_dir_variables=args["working_dir_variables"].get<bool>();
          this->working_dir=args["working_dir"].get<std::string>();
        }
        bool command_variables;
        std::vector<std::string> command;
        std::string show_output;
        std::vector<int> success_status;
        bool ignore_success_status;
        bool working_dir_variables;
        std::string working_dir;
        ActionStatus run_action();
    };
    class CopyFolderAction {
      public:
        CopyFolderAction(const json& args) {
          check_arg_string(args,"source_folder");
          check_arg_string(args,"destination_folder");
          this->source_folder_variables=args["source_folder_variables"].get<bool>();
          this->source_folder=args["source_folder"].get<std::string>();
          this->destination_folder_variables=args["destination_folder_variables"].get<bool>();
          this->destination_folder=args["destination_folder"].get<std::string>();
        }
        bool source_folder_variables;
        std::string source_folder;
        bool destination_folder_variables;
        std::string destination_folder;
        ActionStatus run_action();
    };
    class ExtractFromCacheAction {
      public:
        ExtractFromCacheAction(const json& args) {
          check_arg_string(args,"target");
          check_arg_string(args,"output_file");
          this->target_variables=args["target_variables"].get<bool>();
          this->output_file_variables=args["output_file_variables"].get<bool>();
          this->target=args["target"].get<std::string>();
          this->output_file=args["output_file"].get<std::string>();
        }
        bool target_variables;
        std::string target;
        bool output_file_variables;
        std::string output_file;
        ActionStatus run_action();
    };
    class StoreInCacheAction {
      public:
        StoreInCacheAction(const json& args) {
          check_arg_string(args,"key");
          check_arg_string(args,"file");
          this->key_variables=args["key_variables"].get<bool>();
          this->file_variables=args["file_variables"].get<bool>();
          this->overwrite_allowed=args["overwrite_allowed"].get<bool>();
          this->key=args["key"].get<std::string>();
          this->file=args["file"].get<std::string>();
        }
        bool key_variables;
        std::string key;
        bool file_variables;
        std::string file;
        bool overwrite_allowed;
        ActionStatus run_action();
    };
    class EnsureFolderResetAction {
      public:
        EnsureFolderResetAction(const json& args) {
          check_arg_string(args,"path");
          this->path_variables=args["path_variables"].get<bool>();
          this->path=args["path"].get<std::string>();
        }
        bool path_variables;
        std::string path;
        ActionStatus run_action();
    };
    class RunActionsIfAction {
      public:
        RunActionsIfAction(const json& args,bool is_threading_allowed,std::string root_folder) {
          if (!args.contains("condition")) throw std::runtime_error("Condition isn't provided.");
          if (!args["condition"].is_object()) throw std::runtime_error("Condition isn't a dictionnary.");
          if (!args["actions"].is_array()) throw std::runtime_error("Provided actions aren't stored in a list.");
          for (const auto& act:args["actions"]) {
            if (!act.is_object()) throw std::runtime_error("One of the action isn't a dictionnary.");
            if (!act.contains("action")) throw std::runtime_error("Action isn't provided.");
            if (!act["action"].is_string()) throw std::runtime_error("Action isn't a string.");
            if (find(threaded_actions.begin(),threaded_actions.end(),act["action"].get<std::string>())!=threaded_actions.end() && !is_threading_allowed) throw std::runtime_error("Multithreaded actions aren't allowed in this module, and so can not be executed from RunActionsIfAction.");
            if (!act.contains("args")) throw std::runtime_error("Action arguments aren't provided.");
            if (!act["args"].is_object()) throw std::runtime_error("Action arguments aren't stored in a dictionnary.");
            actions.push_back(act);
          }
          this->condition=args["condition"];
          this->is_threading_allowed=is_threading_allowed;
          this->root_folder=root_folder;
        }
        json condition;
        std::vector<json> actions;
        bool is_threading_allowed;
        std::string root_folder;
        ActionStatus run_action();
    };
    class RunActionsIfElseAction {
      public:
        RunActionsIfElseAction(const json& args,bool is_threading_allowed,std::string root_folder) {
          if (!args.contains("condition")) throw std::runtime_error("Condition isn't provided.");
          if (!args["condition"].is_object()) throw std::runtime_error("Condition isn't a dictionnary.");
          if (!args.contains("actions_if")) throw std::runtime_error("No actions are provided.");
          if (!args["actions_if"].is_array()) throw std::runtime_error("Provided actions aren't stored in a list.");
          for (const auto& act:args["actions_if"]) {
            if (!act.is_object()) throw std::runtime_error("One of the action isn't a dictionnary.");
            if (!act.contains("action")) throw std::runtime_error("Action isn't provided.");
            if (!act["action"].is_string()) throw std::runtime_error("Action isn't a string.");
            if (find(threaded_actions.begin(),threaded_actions.end(),act["action"].get<std::string>())!=threaded_actions.end() && !is_threading_allowed) throw std::runtime_error("Multithreaded actions aren't allowed in this module, and so can not be executed from RunActionsIfAction.");
            if (!act.contains("args")) throw std::runtime_error("Action arguments aren't provided.");
            if (!act["args"].is_object()) throw std::runtime_error("Action arguments aren't stored in a dictionnary.");
            actions_if.push_back(act);
          }
          if (!args.contains("actions_else")) throw std::runtime_error("No actions are provided.");
          if (!args["actions_else"].is_array()) throw std::runtime_error("Provided actions aren't stored in a list.");
          for (const auto& act:args["actions_else"]) {
            if (!act.is_object()) throw std::runtime_error("One of the action isn't a dictionnary.");
            if (!act.contains("action")) throw std::runtime_error("Action isn't provided.");
            if (!act["action"].is_string()) throw std::runtime_error("Action isn't a string.");
            if (find(threaded_actions.begin(),threaded_actions.end(),act["action"].get<std::string>())!=threaded_actions.end() && !is_threading_allowed) throw std::runtime_error("Multithreaded actions aren't allowed in this module, and so can not be executed from RunActionsIfAction.");
            if (!act.contains("args")) throw std::runtime_error("Action arguments aren't provided.");
            if (!act["args"].is_object()) throw std::runtime_error("Action arguments aren't stored in a dictionnary.");
            actions_else.push_back(act);
          }
          this->condition=args["condition"];
          this->is_threading_allowed=is_threading_allowed;
          this->root_folder=root_folder;
        }
        json condition;
        std::vector<json> actions_if;
        std::vector<json> actions_else;
        bool is_threading_allowed;
        std::string root_folder;
        ActionStatus run_action();
    };
    class RunCommandStrAction {
      public:
        RunCommandStrAction(const json& args) {
          check_arg_string(args,"command");
          if (!args.contains("show_output")) throw std::runtime_error("Show output isn't provided.");
          if (!args["show_output"].is_string()) throw std::runtime_error("Show output isn't a string");
          if (args["show_output"]!="live" && args["show_output"]!="on_failure" && args["show_output"]!="silent") {
            throw std::runtime_error("\""+args["show_output"].get<std::string>()+"\" isn't a valid output mode.");
          }
          if (!args.contains("success_status")) throw std::runtime_error("Success status isn't provided.");
          if (!args["success_status"].is_array()) throw std::runtime_error("Success status isn't a boolean");
          for (auto& arg:args["success_status"]) {
            if (!arg.is_number_integer()) throw std::runtime_error("One of the status code isn't an integer.");
          }
          if (!args.contains("ignore_success_status")) throw std::runtime_error("Ignore success status isn't provided.");
          if (!args["ignore_success_status"].is_boolean()) throw std::runtime_error("Ignore success status isn't a boolean");
          this->command_variables=args["command_variables"].get<bool>();
          this->command=args["command"].get<std::string>();
          this->show_output=args["show_output"].get<std::string>();
          this->success_status=args["success_status"].get<std::vector<int>>();
          this->ignore_success_status=args["ignore_success_status"].get<bool>();
        }
        bool command_variables;
        std::string command;
        std::string show_output;
        std::vector<int> success_status;
        bool ignore_success_status;
        ActionStatus run_action();
    };
    class ComputeElementHashAction {
      public:
        ComputeElementHashAction(const json& args) {
          check_arg_string(args,"element");
          if (!args.contains("output_variable")) throw std::runtime_error("Output variable isn't provided.");
          if (!args["output_variable"].is_string()) throw std::runtime_error("Output variable isn't a string.");
          this->element_variables=args["element_variables"].get<bool>();
          this->element=args["element"].get<std::string>();
          this->output_variable=args["output_variable"].get<std::string>();
        }
        bool element_variables;
        std::string element;
        std::string output_variable;
        ActionStatus run_action();
    };
    class CompileMultipleCppAction {
      public:
        CompileMultipleCppAction(const json& args) {
          check_arg_vector_string(args,"source_files");
          check_arg_string(args,"compiler");
          check_arg_vector_string(args,"pre_arguments");
          check_arg_vector_string(args,"post_arguments");
          check_arg_vector_string(args,"output_files");
          check_arg_string(args,"headers_command");
          if (!args.contains("success_status")) throw std::runtime_error("Success status isn't provided.");
          if (!args["success_status"].is_array()) throw std::runtime_error("Success status isn't a boolean");
          for (auto& arg:args["success_status"]) {
            if (!arg.is_number_integer()) throw std::runtime_error("One of the status code isn't an integer.");
          }
          if (!args.contains("ignore_success_status")) throw std::runtime_error("Ignore success status isn't provided.");
          if (!args["ignore_success_status"].is_boolean()) throw std::runtime_error("Ignore success status isn't a boolean");
          if (!args.contains("cache_authorized")) throw std::runtime_error("Cache authorized isn't provided.");
          if (!args["cache_authorized"].is_boolean()) throw std::runtime_error("Cache authorized isn't a boolean");
          if (!args.contains("source_files_path_completion")) throw std::runtime_error("Source files path completion isn't provided.");
          if (!args["source_files_path_completion"].is_boolean()) throw std::runtime_error("Source files path completion isn't a boolean");
          this->source_files_path_completion=args["source_files_path_completion"].get<bool>();
          if (this->source_files_path_completion) {
            if (!args.contains("path_completion_source_ext")) throw std::runtime_error("Path completion sources extension isn't provided");
            if (!args["path_completion_source_ext"].is_string()) throw std::runtime_error("Path completion sources extension isn't a string");
            if (!args.contains("path_completion_output_ext")) throw std::runtime_error("Path completion output extension isn't provided");
            if (!args["path_completion_output_ext"].is_string()) throw std::runtime_error("Path completion output extension isn't a string");
            this->path_completion_source_ext=args["path_completion_source_ext"].get<std::string>();
            this->path_completion_output_ext=args["path_completion_output_ext"].get<std::string>();
          }
          this->source_files_variables=args["source_files_variables"].get<bool>();
          this->compiler_variables=args["compiler_variables"].get<bool>();
          this->pre_arguments_variables=args["pre_arguments_variables"].get<bool>();
          this->post_arguments_variables=args["post_arguments_variables"].get<bool>();
          this->output_files_variables=args["output_files_variables"].get<bool>();
          this->ignore_success_status=args["ignore_success_status"].get<bool>();
          this->cache_authorized=args["cache_authorized"].get<bool>();
          this->headers_command_variables=args["headers_command_variables"].get<bool>();
          this->compiler=args["compiler"].get<std::string>();
          this->headers_command=args["headers_command"].get<std::string>();
          this->source_files=args["source_files"].get<std::vector<std::string>>();
          this->pre_arguments=args["pre_arguments"].get<std::vector<std::string>>();
          this->post_arguments=args["post_arguments"].get<std::vector<std::string>>();
          this->output_files=args["output_files"].get<std::vector<std::string>>();
          this->success_status=args["success_status"].get<std::vector<int>>();
        }
        bool source_files_path_completion;
        bool source_files_variables;
        std::vector<std::string> source_files;
        bool compiler_variables;
        std::string compiler;
        bool pre_arguments_variables;
        std::vector<std::string> pre_arguments;
        bool post_arguments_variables;
        std::vector<std::string> post_arguments;
        bool output_files_variables;
        std::vector<std::string> output_files;
        std::vector<int> success_status;
        bool ignore_success_status;
        bool cache_authorized;
        bool headers_command_variables;
        std::string headers_command;
        std::string path_completion_source_ext;
        std::string path_completion_output_ext;
        ActionStatus run_action();
    };
    class CopyFileAction {
      public:
        CopyFileAction(const json& args) {
          check_arg_string(args,"source_file");
          check_arg_string(args,"destination_folder");
          this->source_file_variables=args["source_file_variables"].get<bool>();
          this->source_file=args["source_file"].get<std::string>();
          this->destination_folder_variables=args["destination_folder_variables"].get<bool>();
          this->destination_folder=args["destination_folder"].get<std::string>();
        }
        bool source_file_variables;
        std::string source_file;
        bool destination_folder_variables;
        std::string destination_folder;
        ActionStatus run_action();
    };
    class CreateFat32Action {
      public:
        CreateFat32Action(const json& args) {
          check_arg_string(args,"key");
          if (!args.contains("size")) throw std::runtime_error("Size isn't provided.");
          if (!args["size"].is_number_unsigned()) throw std::runtime_error("Size isn't an integer.");
          this->key_variables=args["key_variables"].get<bool>();
          this->key=args["key"].get<std::string>();
          this->size=args["size"].get<size_t>();
        }
        bool key_variables;
        std::string key;
        size_t size;
        ActionStatus run_action();
    };
    class CreateFolderFat32Action {
      public:
        CreateFolderFat32Action(const json& args) {
          check_arg_string(args,"key");
          check_arg_string(args,"full_path");
          this->key_variables=args["key_variables"].get<bool>();
          this->key=args["key"].get<std::string>();
          this->full_path_variables=args["full_path_variables"].get<bool>();
          this->full_path=args["full_path"].get<std::string>();
        }
        bool key_variables;
        std::string key;
        bool full_path_variables;
        std::string full_path;
        ActionStatus run_action();
    };
    class CreateFileFat32Action {
      public:
        CreateFileFat32Action(const json& args) {
          check_arg_string(args,"key");
          check_arg_string(args,"source_path");
          check_arg_string(args,"full_path");
          if (args.contains("is_vftm_target")) {
            if (!args["is_vftm_target"].is_boolean()) throw std::runtime_error("Is VFTM target isn't an boolean.");
            this->is_vftm_target=args["is_vftm_target"].get<bool>();
          }
          this->key_variables=args["key_variables"].get<bool>();
          this->key=args["key"].get<std::string>();
          this->source_path_variables=args["source_path_variables"].get<bool>();
          this->source_path=args["source_path"].get<std::string>();
          this->full_path_variables=args["full_path_variables"].get<bool>();
          this->full_path=args["full_path"].get<std::string>();
        }
        bool is_vftm_target=false;
        bool key_variables;
        std::string key;
        bool source_path_variables;
        std::string source_path;
        bool full_path_variables;
        std::string full_path;
        ActionStatus run_action();
    };
    class ExportFat32Action {
      public:
        ExportFat32Action(const json& args) {
          check_arg_string(args,"key");
          check_arg_string(args,"export_path");
          if (!args.contains("generate_vftm")) throw std::runtime_error("Generate VFTM isn't provided.");
          if (!args["generate_vftm"].is_boolean()) throw std::runtime_error("Generate VFTM isn't a boolean.");
          this->generate_vftm=args["generate_vftm"].get<bool>();
          if (this->generate_vftm) {
            if (!args.contains("disk_guid_var")) throw std::runtime_error("Disk GUID variable must be provided when generate_vftm is true.");
            if (!args["disk_guid_var"].is_string()) throw std::runtime_error("Disk GUID variable must be a string.");
            if (!args.contains("efi_part_unique_guid_var")) throw std::runtime_error("EFI partition unique GUID variable must be provided when generate_vftm is true.");
            if (!args["efi_part_unique_guid_var"].is_string()) throw std::runtime_error("EFI partition unique GUID variable must be a boolean.");
            this->disk_guid_var=args["disk_guid_var"].get<std::string>();
            this->efi_part_unique_guid_var=args["efi_part_unique_guid_var"].get<std::string>();
          }
          this->key_variables=args["key_variables"].get<bool>();
          this->key=args["key"].get<std::string>();
          this->export_path_variables=args["export_path_variables"].get<bool>();
          this->export_path=args["export_path"].get<std::string>();
        }
        bool key_variables;
        std::string key;
        bool export_path_variables;
        std::string export_path;
        bool generate_vftm;
        std::string disk_guid_var;
        std::string efi_part_unique_guid_var;
        ActionStatus run_action();
    };
    class CreateDiskAction {
      public:
        CreateDiskAction(const json& args) {
          check_arg_string(args,"key");
          check_arg_string(args,"disk_guid");
          if (!args.contains("size")) throw std::runtime_error("Size isn't provided.");
          if (!args["size"].is_number_unsigned()) throw std::runtime_error("Size isn't an integer.");
          this->key_variables=args["key_variables"].get<bool>();
          this->key=args["key"].get<std::string>();
          this->disk_guid_variables=args["disk_guid_variables"].get<bool>();
          this->disk_guid=args["disk_guid"].get<std::string>();
          this->size=args["size"].get<size_t>();
        }
        bool key_variables;
        std::string key;
        size_t size;
        bool disk_guid_variables;
        std::string disk_guid;
        ActionStatus run_action();
    };
    class AddPartitionDiskAction {
      public:
        AddPartitionDiskAction(const json& args) {
          check_arg_string(args,"key");
          check_arg_string(args,"type_guid");
          check_arg_string(args,"unique_guid");
          check_arg_string(args,"name");
          check_arg_string(args,"source_file");
          this->key_variables=args["key_variables"].get<bool>();
          this->key=args["key"].get<std::string>();
          this->type_guid_variables=args["type_guid_variables"].get<bool>();
          this->type_guid=args["type_guid"].get<std::string>();
          this->unique_guid_variables=args["unique_guid_variables"].get<bool>();
          this->unique_guid=args["unique_guid"].get<std::string>();
          this->name_variables=args["name_variables"].get<bool>();
          this->name=args["name"].get<std::string>();
          this->source_file_variables=args["source_file_variables"].get<bool>();
          this->source_file=args["source_file"].get<std::string>();
        }
        bool key_variables;
        std::string key;
        bool type_guid_variables;
        std::string type_guid;
        bool unique_guid_variables;
        std::string unique_guid;
        bool name_variables;
        std::string name;
        bool source_file_variables;
        std::string source_file;
        ActionStatus run_action();
    };
    class ExportDiskAction {
      public:
        ExportDiskAction(const json& args) {
          check_arg_string(args,"key");
          check_arg_string(args,"export_path");
          this->key_variables=args["key_variables"].get<bool>();
          this->key=args["key"].get<std::string>();
          this->export_path_variables=args["export_path_variables"].get<bool>();
          this->export_path=args["export_path"].get<std::string>();
        }
        bool key_variables;
        std::string key;
        bool export_path_variables;
        std::string export_path;
        ActionStatus run_action();
    };
    class VFTMLoadCryptoLibAction {
      public:
        VFTMLoadCryptoLibAction(const json& args) {
          check_arg_string(args,"lib_path");
          this->lib_path_variables=args["lib_path_variables"].get<bool>();
          this->lib_path=args["lib_path"].get<std::string>();
        }
        bool lib_path_variables;
        std::string lib_path;
        ActionStatus run_action();
    };
    class VFTMRunKeysGeneratorAction {
      public:
        VFTMRunKeysGeneratorAction(const json& args) {
          check_arg_vector_string(args,"command");
          check_arg_string(args,"working_dir");
          check_arg_string(args,"socket_path");
          if (!args.contains("success_status")) throw std::runtime_error("Success status isn't provided.");
          if (!args["success_status"].is_array()) throw std::runtime_error("Success status isn't a boolean");
          for (auto& arg:args["success_status"]) {
            if (!arg.is_number_integer()) throw std::runtime_error("One of the status code isn't an integer.");
          }
          if (!args.contains("ignore_success_status")) throw std::runtime_error("Ignore success status isn't provided.");
          if (!args["ignore_success_status"].is_boolean()) throw std::runtime_error("Ignore success status isn't a boolean");
          this->command_variables=args["command_variables"].get<bool>();
          this->command=args["command"].get<std::vector<std::string>>();
          this->socket_path_variables=args["socket_path_variables"].get<bool>();
          this->socket_path=args["socket_path"].get<std::string>();
          this->success_status=args["success_status"].get<std::vector<int>>();
          this->ignore_success_status=args["ignore_success_status"].get<bool>();
          this->working_dir_variables=args["working_dir_variables"].get<bool>();
          this->working_dir=args["working_dir"].get<std::string>();
        }
        bool command_variables;
        std::vector<std::string> command;
        bool socket_path_variables;
        std::string socket_path;
        std::vector<int> success_status;
        bool ignore_success_status;
        bool working_dir_variables;
        std::string working_dir;
        ActionStatus run_action();
    };
    using ParallelAction=std::variant<RunCommandWaitAction,
                                      SaveCommandContentAction,
                                      CompileOneAsmAction,
                                      EnsureFolderExistenceAction,
                                      MoveFileAction,
                                      CompileOneCppAction,
                                      RunCommandWaitDirAction,
                                      CopyFolderAction,
                                      ExtractFromCacheAction,
                                      StoreInCacheAction,
                                      EnsureFolderResetAction,
                                      RunActionsIfAction,
                                      RunCommandStrAction,
                                      RunActionsIfElseAction,
                                      ComputeElementHashAction,
                                      CopyFileAction,
                                      CreateFat32Action,
                                      CreateFolderFat32Action,
                                      CreateFileFat32Action,
                                      ExportFat32Action,
                                      CreateDiskAction,
                                      AddPartitionDiskAction,
                                      ExportDiskAction,
                                      VFTMLoadCryptoLibAction,
                                      VFTMRunKeysGeneratorAction>;
    ParallelAction return_pararrel_action(const json& args,std::string action_name);
    class RunActionsParallelAction {
      public:
        RunActionsParallelAction (const json& args) {
          if (!args.contains("actions")) throw std::runtime_error("No actions are provided.");
          if (!args["actions"].is_array()) throw std::runtime_error("Provided actions aren't stored in a list.");
          for (const auto& act:args["actions"]) {
            if (!act.is_object()) throw std::runtime_error("One of the action isn't a dictionnary.");
            if (!act.contains("action")) throw std::runtime_error("Action isn't provided.");
            if (!act["action"].is_string()) throw std::runtime_error("Action isn't a string.");
            if (!act.contains("args")) throw std::runtime_error("Action arguments aren't provided.");
            if (!act["args"].is_object()) throw std::runtime_error("Action arguments aren't stored in a dictionnary.");
            actions.push_back(return_pararrel_action(act["args"],act["action"]));
          }
        }
        std::vector<ParallelAction> actions;
        ActionStatus run_action();
    };
    class RunSubmoduleParallelAction {
      public:
        RunSubmoduleParallelAction(const json& args) {
          check_arg_vector_string(args,"submodules");
          for (const auto& act:args["submodules"]) {
            submodules.push_back(act.get<std::string>());
          }
          this->submodules_variables=args["submodules_variables"].get<bool>();
        }
        bool submodules_variables;
        std::vector<std::string> submodules;
        ActionStatus run_action();
    };
    class VyldCompilationAction {
      public:
        VyldCompilationAction(const json& args) {
          check_arg_vector_string(args,"source_files");
          check_arg_vector_string(args,"source_asm");
          check_arg_string(args,"compiler");
          check_arg_string(args,"assembler");
          check_arg_string(args,"linker");
          check_arg_string(args,"compiler_flags");
          check_arg_string(args,"output_file");
          check_arg_string(args,"headers_command");
          if (!args.contains("source_files_path_completion")) throw std::runtime_error("Source file path completion isn't provided.");
          if (!args["source_files_path_completion"].is_boolean()) throw std::runtime_error("Source file path completion isn't a boolean.");
          if (!args.contains("source_asm_path_completion")) throw std::runtime_error("Source ASM path completion isn't provided.");
          if (!args["source_asm_path_completion"].is_boolean()) throw std::runtime_error("Source ASM path completion isn't a boolean.");
          if (!args.contains("block_if_fail")) throw std::runtime_error("Block if fail isn't provided.");
          if (!args["block_if_fail"].is_boolean()) throw std::runtime_error("Block if fail isn't a boolean.");
          if (!args.contains("object_files_cache_authorized")) throw std::runtime_error("Object files caching authorized isn't provided.");
          if (!args["object_files_cache_authorized"].is_boolean()) throw std::runtime_error("Object files caching authorized isn't a boolean.");
          if (!args.contains("payloads")) throw std::runtime_error("Payloads aren't provided.");
          if (!args["payloads"].is_array()) throw std::runtime_error("Payloads aren't stored in a list.");
          this->source_files_path_completion=args["source_files_path_completion"].get<bool>();
          this->source_asm_path_completion=args["source_asm_path_completion"].get<bool>();
          this->source_files_variables=args["source_files_variables"].get<bool>();
          this->source_asm_variables=args["source_asm_variables"].get<bool>();
          this->compiler_variables=args["compiler_variables"].get<bool>();
          this->assembler_variables=args["assembler_variables"].get<bool>();
          this->linker_variables=args["linker_variables"].get<bool>();
          this->compiler_flags_variables=args["compiler_flags_variables"].get<bool>();
          this->output_file_variables=args["output_file_variables"].get<bool>();
          this->block_if_fail=args["block_if_fail"].get<bool>();
          this->object_files_cache_authorized=args["object_files_cache_authorized"].get<bool>();
          this->headers_command_variables=args["headers_command_variables"].get<bool>();
          this->source_files=args["source_files"].get<std::vector<std::string>>();
          this->source_asm=args["source_asm"].get<std::vector<std::string>>();
          this->compiler=args["compiler"].get<std::string>();
          this->assembler=args["assembler"].get<std::string>();
          this->linker=args["linker"].get<std::string>();
          this->compiler_flags=args["compiler_flags"].get<std::string>();
          this->output_file=args["output_file"].get<std::string>();
          this->headers_command=args["headers_command"].get<std::string>();
          this->payloads=args["payloads"].get<std::vector<json>>();
        }
        bool source_files_path_completion;
        bool source_files_variables;
        std::vector<std::string> source_files;
        bool compiler_variables;
        std::string compiler;
        bool source_asm_path_completion;
        bool source_asm_variables;
        std::vector<std::string> source_asm;
        bool assembler_variables;
        std::string assembler;
        bool linker_variables;
        std::string linker;
        bool compiler_flags_variables;
        std::string compiler_flags;
        bool output_file_variables;
        std::string output_file;
        bool block_if_fail;
        bool object_files_cache_authorized;
        bool headers_command_variables;
        std::string headers_command;
        std::vector<json> payloads;
        ActionStatus run_action();
    };
    using Action=std::variant<RunSubmoduleAction,
                              RunCommandWaitAction,
                              RunActionsParallelAction,
                              SaveCommandContentAction,
                              CompileOneAsmAction,
                              EnsureFolderExistenceAction,
                              MoveFileAction,
                              CompileOneCppAction,
                              VyldCompilationAction,
                              RunSubmoduleIfAction,
                              RunCommandWaitDirAction,
                              CopyFolderAction,
                              RunSubmoduleParallelAction,
                              ExtractFromCacheAction,
                              StoreInCacheAction,
                              EnsureFolderResetAction,
                              RunActionsIfAction,
                              RunCommandStrAction,
                              RunActionsIfElseAction,
                              ComputeElementHashAction,
                              CompileMultipleCppAction,
                              CopyFileAction,
                              CreateFat32Action,
                              CreateFolderFat32Action,
                              CreateFileFat32Action,
                              ExportFat32Action,
                              CreateDiskAction,
                              AddPartitionDiskAction,
                              ExportDiskAction,
                              VFTMLoadCryptoLibAction,
                              VFTMRunKeysGeneratorAction>;
    Action return_action(const json &args,std::string action_name,bool is_threading_allowed,std::string root_folder);
  }
  namespace module {
    class Module {
      public:
        Module(std::string file,bool is_threading_allowed) {
          std::ifstream f(file);
          if (!f) {
            throw std::runtime_error(file+" couldn't be opened.");
          }
          json j=json::parse(f);
          if (!j.contains("version")) throw std::runtime_error("Syntax version isn't provided.");
          if (!j["version"].is_string()) throw std::runtime_error("Syntax version isn't a string.");
          if (j["version"]!=syntax_version) throw std::runtime_error("Syntax version is "+j["version"].get<std::string>()+". Expected "+syntax_version+".");
          if (j.contains("root_folder")) {
            if (!j["root_folder"].is_string()) throw std::runtime_error("Root folder isn't a string.");
            this->root_folder=vybuild::parser::root_folder_parsing(j["root_folder"].get<std::string>(),file);
          } else {
            this->root_folder=vybuild::parser::root_folder_parsing("%filefolder%",file);
          }
          if (!j.contains("run_context")) throw std::runtime_error("Run context isn't provided.");
          if (!j["run_context"].is_string()) throw std::runtime_error("Run context isn't a string.");
          if (j["run_context"]!="root" && j["run_context"]!="sub" && j["run_context"]!="both") throw std::runtime_error("\""+j["run_context"].get<std::string>()+"\" isn't a string.");
          this->run_context=j["run_context"].get<std::string>();
          if (!j.contains("name")) throw std::runtime_error("Name isn't provided.");
          if (!j["name"].is_string()) throw std::runtime_error("Name isn't a string.");
          this->name=j["name"].get<std::string>();
          if (this->run_context=="root" && j.contains("global_vars")) {
            if (!j["global_vars"].is_object()) throw std::runtime_error("Global variables aren't in a list.");
            for (const auto& [var_name,value]:j["global_vars"].items()) {
              vybuild::vars::set_global_variable("\\$"+var_name+"\\$",value);
            }
          } else if (this->run_context!="root" && j.contains("global_vars")){
            throw std::runtime_error("Global variables are only available for modules that are guaranteed to be runned as root.");
          }
          if (this->run_context=="root" && j.contains("global_uuid")) {
            if (!j["global_uuid"].is_array()) throw std::runtime_error("Global UUID aren't in a list.");
            for (const auto& var_name:j["global_uuid"].items()) {
              uuid_t id;
              uuid_generate_random(id);
              char out[37];
              uuid_unparse_lower(id,out);
              vybuild::vars::set_global_variable("\\$"+var_name.value().get<std::string>()+"\\$",std::string(out));
            }
          } else if (this->run_context!="root" && j.contains("global_uuid")){
            throw std::runtime_error("Global UUID are only available for modules that are guaranteed to be runned as root.");
          }
          if (!j.contains("actions")) throw std::runtime_error("Couldn't find any action inside module.");
          if (!j["actions"].is_array()) throw std::runtime_error("Actions aren't in a list.");
          for (const auto& act:j["actions"]) {
            if (!act.is_object()) throw std::runtime_error("One of the action isn't a dictionnary.");
            if (!act.contains("action")) throw std::runtime_error("Action isn't provided.");
            if (!act["action"].is_string()) throw std::runtime_error("Action isn't a string.");
            if (!act.contains("args")) throw std::runtime_error("Action arguments aren't provided.");
            if (!act["args"].is_object()) throw std::runtime_error("Action arguments aren't stored in a dictionnary.");
            actions.push_back(vybuild::actions::return_action(act["args"],act["action"],is_threading_allowed,this->root_folder));
          }
        }
        std::string root_folder;
        std::string run_context;
        std::string name;
        std::vector<vybuild::actions::Action> actions;
        vybuild::actions::ActionStatus run_module(bool is_root,bool is_threaded) {
          if (this->run_context=="root" && !is_root) {
            throw std::runtime_error("Module isn't supposed to be ran as a submodule.");
          } else if (this->run_context=="sub" && is_root) {
            throw std::runtime_error("Module isn't supposed to be ran as root module.");
          }
          if (is_threaded) unshare(CLONE_FS);
          char path[PATH_MAX];
          getcwd(path,sizeof(path));
          chdir(this->root_folder.c_str());
          for (auto& a:actions) {
            vybuild::actions::ActionStatus status=std::visit([](auto& act) {
              return act.run_action();
            },a);
            if (status!=vybuild::actions::ActionStatus::Success && status!=vybuild::actions::ActionStatus::ExitSuccess) {
              chdir(path);
              return status;
            }
            if (status==vybuild::actions::ActionStatus::ExitSuccess) {
              chdir(path);
              return vybuild::actions::ActionStatus::Success;
            }
          }
          chdir(path);
          return vybuild::actions::ActionStatus::Success;
        }
    };
  }
}
#endif