// SPDX-License-Identifier: Apache-2.0

// SPDX-FileCopyrightText: Copyright The WasmEdge Authors

//===-- wasmedge/driver/tool.h - Tool entry point -------------------------===//

//

// Part of the WasmEdge Project.

//

//===----------------------------------------------------------------------===//

///

/// \file

/// This file contains the entry point for the tooling executable.

///

//===----------------------------------------------------------------------===//

#pragma once

#include "driver/options.h"

#include "plugin/plugin.h"

#include "po/argument_parser.h"

#include <filesystem>

#include <optional>

#include <string_view>

namespace WasmEdge {

namespace VM {

class VM;

} // namespace VM

namespace Driver {

using namespace std::literals;

struct DriverToolOptions : public DriverProposalOptions,

                           public DriverStatisticsOptions,

                           public DriverLoggingOptions {

  DriverToolOptions()

      : SoName(PO::Description("Wasm or so file"sv),

               PO::MetaVar("WASM_OR_SO"sv)),

        Args(PO::Description("Execution arguments"sv), PO::MetaVar("ARG"sv)),

        Reactor(PO::Description(

            "Enable reactor mode. Reactor mode calls `_initialize` if exported."sv)),

        Dir(PO::Description(

                "Binding directories into WASI virtual filesystem. Each "

                "directory can be specified as --dir `host_path`. You can also "

                "map a guest directory to a host directory by --dir "

                "`guest_path:host_path`, where `guest_path` specifies the path "

                "that will correspond to `host_path` for calls like `fopen` in "

                "the guest. The default permission is `readwrite`, however, "

                "you can use --dir `guest_path:host_path:readonly` to make the "

                "mapping directory become a read only mode."sv),

            PO::MetaVar("PREOPEN_DIRS"sv)),

        Env(PO::Description(

                "Environ variables. Each variable can be specified as --env "

                "`NAME=VALUE`."sv),

            PO::MetaVar("ENVS"sv)),

        PropComponent(PO::Description(

            "Enable Component Model proposal, this is experimental"sv)),

        ConfEnableJIT(

            PO::Description("Enable Just-In-Time compiler for running WASM"sv)),

        ConfEnableCoredump(PO::Description(

            "Enable coredump when WebAssembly enters a trap. Requires the "

            "interpreter run mode, otherwise it is disabled"sv)),

        ConfCoredumpWasmgdb(

            PO::Description("Enable coredump in the format expected by the "

                            "wasmgdb debugger, which differs from the one of "

                            "the WebAssembly tool conventions"sv)),

        ConfForceInterpreter(

            PO::Description("Forcibly run WASM in interpreter mode."sv)),

        ConfRunMode(PO::Description("Set execution mode. Valid values: "

                                    "interpreter, jit, aot, lazyjit. "

                                    "Default is interpreter."sv),

                    PO::MetaVar("MODE"sv), PO::DefaultValue(std::string())),

        ConfAFUNIX(PO::Description("Enable UNIX domain sockets"sv)),

        TimeLim(

            PO::Description(

                "Limitation of maximum time(in milliseconds) for execution, "

                "default value is 0 for no limitations"sv),

            PO::MetaVar("TIMEOUT"sv), PO::DefaultValue<uint64_t>(0)),

        GasLim(

            PO::Description(

                "Limitation of execution gas. Upper bound can be specified as "

                "--gas-limit `GAS_LIMIT`."sv),

            PO::MetaVar("GAS_LIMIT"sv)),

        MemLim(

            PO::Description(

                "Limitation of pages(as size of 64 KiB) in every memory "

                "instance. Upper bound can be specified as --memory-page-limit "

                "`PAGE_COUNT`."sv),

            PO::MetaVar("PAGE_COUNT"sv)),

        StackLim(PO::Description(

                     "Limitation of stack size (in bytes) for execution, "

                     "default value is 0 for the engine default (8 MiB for "

                     "the interpreter, 512 KiB for compiled code)"sv),

                 PO::MetaVar("BYTES"sv), PO::DefaultValue<uint64_t>(0)),

        LinkedModules(

            PO::Description(

                "Register additional WASM modules for linking. Each module "

                "can be specified as --module `name:path`, where `name` is "

                "the module name to export and `path` is the WASM file path."sv),

            PO::MetaVar("MODULES"sv)),

        ForbiddenPlugins(PO::Description("List of plugins to ignore."sv),

                         PO::MetaVar("NAMES"sv)) {}

  PO::Option<std::string> SoName;

  PO::List<std::string> Args;

  PO::Option<PO::Toggle> Reactor;

  PO::List<std::string> Dir;

  PO::List<std::string> Env;

  PO::Option<PO::Toggle> PropComponent;

  PO::Option<PO::Toggle> ConfEnableJIT;

  PO::Option<PO::Toggle> ConfEnableCoredump;

  PO::Option<PO::Toggle> ConfCoredumpWasmgdb;

  PO::Option<PO::Toggle> ConfForceInterpreter;

  PO::Option<std::string> ConfRunMode;

  PO::Option<PO::Toggle> ConfAFUNIX;

  PO::Option<uint64_t> TimeLim;

  PO::List<uint64_t> GasLim;

  PO::List<uint64_t> MemLim;

  PO::Option<uint64_t> StackLim;

  PO::List<std::string> LinkedModules;

  PO::List<std::string> ForbiddenPlugins;

private:

  void addGlobalOptions(PO::ArgumentParser &Parser) noexcept {

    addLoggingOptions(Parser);

    Parser.add_option("forbidden-plugin"sv, ForbiddenPlugins);

  }

public:

  /// Take the global options given before the subcommand.

  void inheritGlobalOptions(const DriverToolOptions &Parent) noexcept {

    inheritLoggingOptions(Parent);

    ForbiddenPlugins.value().insert(ForbiddenPlugins.value().begin(),

                                    Parent.ForbiddenPlugins.value().begin(),

                                    Parent.ForbiddenPlugins.value().end());

  }

  void addParserOptions(PO::ArgumentParser &Parser) noexcept {

    addGlobalOptions(Parser);

    addProposalOptions(Parser);

    Parser.add_option("enable-component"sv, PropComponent).add_option(SoName);

  }

  void addLinkerOptions(PO::ArgumentParser &Parser) noexcept {

    addParserOptions(Parser);

    Plugin::Plugin::loadFromDefaultPaths();

    Plugin::Plugin::addPluginOptions(Parser);

    Parser.add_option("dir"sv, Dir)

        .add_option("env"sv, Env)

        .add_option("module"sv, LinkedModules)

        .add_option("memory-page-limit"sv, MemLim);

  }

  void addOptions(PO::ArgumentParser &Parser) noexcept {

    addLinkerOptions(Parser);

    // pure Execution and Profiling flags

    Parser.add_option(Args);

    addStatisticsOptions(Parser);

    Parser.add_option("enable-jit"sv, ConfEnableJIT)

        .add_option("enable-coredump"sv, ConfEnableCoredump)

        .add_option("coredump-for-wasmgdb"sv, ConfCoredumpWasmgdb)

        .add_option("force-interpreter"sv, ConfForceInterpreter)

        .add_option("run-mode"sv, ConfRunMode)

        .add_option("allow-af-unix"sv, ConfAFUNIX)

        .add_option("time-limit"sv, TimeLim)

        .add_option("gas-limit"sv, GasLim)

        .add_option("stack-size-limit"sv, StackLim)

        .add_option("reactor"sv, Reactor);

  }

};

Configure createConfigure(const struct DriverToolOptions &Opt) noexcept;

std::optional<RunMode> parseRunModeArg(std::string_view S) noexcept;

std::optional<std::filesystem::path>

getInputPath(const struct DriverToolOptions &Opt) noexcept;

void setMemoryPageLimit(const struct DriverToolOptions &Opt,

                        Configure &Conf) noexcept;

bool registerLinkedModules(const struct DriverToolOptions &Opt,

                           VM::VM &VM) noexcept;

int Tool(struct DriverToolOptions &Opt) noexcept;

int ParseTool(struct DriverToolOptions &Opt) noexcept;

int ValidateTool(struct DriverToolOptions &Opt) noexcept;

int InstantiateTool(struct DriverToolOptions &Opt) noexcept;

} // namespace Driver

} // namespace WasmEdge