// SPDX-License-Identifier: Apache-2.0

// SPDX-FileCopyrightText: Copyright The WasmEdge Authors

#include "common/configure.h"

#include "common/defines.h"

#include "common/filesystem.h"

#include "common/version.h"

#include "driver/compiler.h"

#include "driver/options.h"

#include "loader/loader.h"

#include "validator/validator.h"

#include "llvm/codegen.h"

#include "llvm/compiler.h"

#include <cstdint>

#include <cstdlib>

#include <memory>

#include <string>

#include <utility>

#include <vector>

namespace WasmEdge {

namespace Driver {

int Compiler([[maybe_unused]] struct DriverCompilerOptions &Opt) noexcept {

  using namespace std::literals;

  std::ios::sync_with_stdio(false);

  Log::setInfoLoggingLevel();

#ifdef WASMEDGE_USE_LLVM

  Configure Conf = createProposalConfigure(Opt);

  if (Opt.PropOptimizationLevel.value() == "0") {

    Conf.getCompilerConfigure().setOptimizationLevel(

        WasmEdge::CompilerConfigure::OptimizationLevel::O0);

  } else if (Opt.PropOptimizationLevel.value() == "1") {

    Conf.getCompilerConfigure().setOptimizationLevel(

        WasmEdge::CompilerConfigure::OptimizationLevel::O1);

  } else if (Opt.PropOptimizationLevel.value() == "3") {

    Conf.getCompilerConfigure().setOptimizationLevel(

        WasmEdge::CompilerConfigure::OptimizationLevel::O3);

  } else if (Opt.PropOptimizationLevel.value() == "s") {

    Conf.getCompilerConfigure().setOptimizationLevel(

        WasmEdge::CompilerConfigure::OptimizationLevel::Os);

  } else if (Opt.PropOptimizationLevel.value() == "z") {

    Conf.getCompilerConfigure().setOptimizationLevel(

        WasmEdge::CompilerConfigure::OptimizationLevel::Oz);

  } else {

    Conf.getCompilerConfigure().setOptimizationLevel(

        WasmEdge::CompilerConfigure::OptimizationLevel::O2);

  }

  // Set interpreter run mode here so the loader reads function bodies fully

  // (the AOT compiler needs the parsed instructions, not AOT symbols).

  Conf.getRuntimeConfigure().setRunMode(WasmEdge::RunMode::Interpreter);

  std::filesystem::path InputPath =

      std::filesystem::absolute(std::filesystem::u8path(Opt.WasmName.value()));

  std::filesystem::path OutputPath =

      std::filesystem::absolute(std::filesystem::u8path(Opt.SoName.value()));

  Loader::Loader Loader(Conf);

  std::vector<Byte> Data;

  if (auto Res = Loader.loadFile(InputPath)) {

    Data = std::move(*Res);

  } else {

    const auto Err = static_cast<uint32_t>(Res.error());

    spdlog::error("Load failed. Error code: {}"sv, Err);

    return EXIT_FAILURE;

  }

  std::unique_ptr<AST::Module> Module;

  if (auto Res = Loader.parseModule(Data)) {

    Module = std::move(*Res);

  } else {

    const auto Err = static_cast<uint32_t>(Res.error());

    spdlog::error("Parse Module failed. Error code: {}"sv, Err);

    return EXIT_FAILURE;

  }

  {

    Validator::Validator ValidatorEngine(Conf);

    if (auto Res = ValidatorEngine.validate(*Module); !Res) {

      const auto Err = static_cast<uint32_t>(Res.error());

      spdlog::error("Validate Module failed. Error code: {}"sv, Err);

      return EXIT_FAILURE;

    }

  }

  {

    if (Opt.ConfDumpIR.value()) {

      Conf.getCompilerConfigure().setDumpIR(true);

    }

    if (Opt.ConfInterruptible.value()) {

      Conf.getCompilerConfigure().setInterruptible(true);

    }

    if (Opt.ConfEnableAllStatistics.value()) {

      Conf.getStatisticsConfigure().setInstructionCounting(true);

      Conf.getStatisticsConfigure().setCostMeasuring(true);

      Conf.getStatisticsConfigure().setTimeMeasuring(true);

    } else {

      if (Opt.ConfEnableInstructionCounting.value()) {

        Conf.getStatisticsConfigure().setInstructionCounting(true);

      }

      if (Opt.ConfEnableGasMeasuring.value()) {

        Conf.getStatisticsConfigure().setCostMeasuring(true);

      }

      if (Opt.ConfEnableTimeMeasuring.value()) {

        Conf.getStatisticsConfigure().setTimeMeasuring(true);

      }

    }

    if (Opt.ConfGenericBinary.value()) {

      Conf.getCompilerConfigure().setGenericBinary(true);

    }

    if (OutputPath.extension().u8string() == WASMEDGE_LIB_EXTENSION) {

      Conf.getCompilerConfigure().setOutputFormat(

          CompilerConfigure::OutputFormat::Native);

    }

    LLVM::Compiler Compiler(Conf);

    if (auto Res = Compiler.checkConfigure(); !Res) {

      const auto Err = static_cast<uint32_t>(Res.error());

      spdlog::error("Compiler Configure failed. Error code: {}"sv, Err);

      return EXIT_FAILURE;

    }

    LLVM::CodeGen CodeGen(Conf);

    if (auto Res = Compiler.compile(*Module); !Res) {

      const auto Err = static_cast<uint32_t>(Res.error());

      spdlog::error("Compilation failed. Error code: {}"sv, Err);

      return EXIT_FAILURE;

    } else if (auto Res2 = CodeGen.codegen(Data, std::move(*Res), OutputPath);

               !Res2) {

      const auto Err = static_cast<uint32_t>(Res2.error());

      spdlog::error("Code Generation failed. Error code: {}"sv, Err);

      return EXIT_FAILURE;

    }

  }

  return EXIT_SUCCESS;

#else

  spdlog::error("Compilation is not supported!"sv);

  return EXIT_FAILURE;

#endif

}

} // namespace Driver

} // namespace WasmEdge