// SPDX-License-Identifier: Apache-2.0

// SPDX-FileCopyrightText: Copyright The WasmEdge Authors

//===-- wasmedge/ast/component/declarator.h - Declarator class definitions ===//

//

// Part of the WasmEdge Project.

//

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

///

/// \file

/// This file contains the declaration of the Declarator related class.

///

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

#pragma once

#include "ast/component/alias.h"

#include "ast/component/descriptor.h"

#include "common/span.h"

#include <string>

#include <string_view>

#include <variant>

#include <vector>

namespace WasmEdge {

namespace AST {

namespace Component {

// Need the forward declaration.

class CoreDefType;

class DefType;

// core:importdecl ::= m:<core:name> n:<core:name> d:<core:importdesc>

//                   => (import m n d)

/// AST Component::CoreImportDecl node.

class CoreImportDecl {

public:

  std::string_view getModuleName() const noexcept { return ModName; }

  std::string &getModuleName() noexcept { return ModName; }

  std::string_view getName() const noexcept { return Name; }

  std::string &getName() noexcept { return Name; }

  const CoreImportDesc &getImportDesc() const noexcept { return Desc; }

  CoreImportDesc &getImportDesc() noexcept { return Desc; }

private:

  std::string ModName;

  std::string Name;

  CoreImportDesc Desc;

};

// core:exportdecl ::= n:<core:name> d:<core:importdesc> => (export n d)

/// AST Component::CoreExportDecl node.

class CoreExportDecl {

public:

  std::string_view getName() const noexcept { return Name; }

  std::string &getName() noexcept { return Name; }

  const CoreImportDesc &getImportDesc() const noexcept { return Desc; }

  CoreImportDesc &getImportDesc() noexcept { return Desc; }

private:

  std::string Name;

  CoreImportDesc Desc;

};

// core:moduledecl ::= 0x00 i:<core:importdecl> => i

//                   | 0x01 t:<core:type>       => t

//                   | 0x02 a:<core:alias>      => a

//                   | 0x03 e:<core:exportdecl> => e

/// AST Component::CoreModuleDecl node.

class CoreModuleDecl {

public:

  const CoreImportDecl &getImport() const noexcept {

    return *std::get_if<CoreImportDecl>(&Decl);

  }

  void setImport(CoreImportDecl &&Imp) noexcept {

    Decl.emplace<CoreImportDecl>(std::move(Imp));

  }

  const CoreDefType *getType() const noexcept {

    return std::get_if<std::unique_ptr<CoreDefType>>(&Decl)->get();

  }

  void setType(std::unique_ptr<CoreDefType> &&Imp) noexcept {

    Decl.emplace<std::unique_ptr<CoreDefType>>(std::move(Imp));

  }

  const CoreAlias &getAlias() const noexcept {

    return *std::get_if<CoreAlias>(&Decl);

  }

  void setAlias(CoreAlias &&A) noexcept {

    Decl.emplace<CoreAlias>(std::move(A));

  }

  const CoreExportDecl &getExport() const noexcept {

    return *std::get_if<CoreExportDecl>(&Decl);

  }

  void setExport(CoreExportDecl &&Exp) noexcept {

    Decl.emplace<CoreExportDecl>(std::move(Exp));

  }

  bool isImport() const noexcept {

    return std::holds_alternative<CoreImportDecl>(Decl);

  }

  bool isType() const noexcept {

    return std::holds_alternative<std::unique_ptr<CoreDefType>>(Decl);

  }

  bool isAlias() const noexcept {

    return std::holds_alternative<CoreAlias>(Decl);

  }

  bool isExport() const noexcept {

    return std::holds_alternative<CoreExportDecl>(Decl);

  }

private:

  std::variant<CoreImportDecl, std::unique_ptr<CoreDefType>, CoreAlias,

               CoreExportDecl>

      Decl;

};

// importdecl ::= na:<nameattributes> et:<externtype> => (import na et)

// exportdecl ::= na:<nameattributes> et:<externtype> => (export na et)

/// Base class of Component::ImportDecl and Component::ExportDecl node.

class ExternDecl {

public:

  std::string_view getName() const noexcept { return Name; }

  std::string &getName() noexcept { return Name; }

  const ExternDesc &getExternDesc() const noexcept { return Desc; }

  ExternDesc &getExternDesc() noexcept { return Desc; }

  std::vector<std::string> &getImplements() noexcept { return Implements; }

  Span<const std::string> getImplements() const noexcept { return Implements; }

  std::vector<std::string> &getExternalIds() noexcept { return ExternalIds; }

  Span<const std::string> getExternalIds() const noexcept {

    return ExternalIds;

  }

  std::vector<std::string> &getVersionSuffixes() noexcept {

    return VersionSuffixes;

  }

  Span<const std::string> getVersionSuffixes() const noexcept {

    return VersionSuffixes;

  }

private:

  std::string Name;

  ExternDesc Desc;

  std::vector<std::string> Implements;

  std::vector<std::string> ExternalIds;

  std::vector<std::string> VersionSuffixes;

};

/// AST Component::ImportDecl node.

class ImportDecl : public ExternDecl {};

/// AST Component::ExportDecl node.

class ExportDecl : public ExternDecl {};

// instancedecl ::= 0x00 t:<core:type>   => t

//                | 0x01 t:<type>        => t

//                | 0x02 a:<alias>       => a

//                | 0x04 ed:<exportdecl> => ed

/// AST Component::InstanceDecl node.

class InstanceDecl {

public:

  const CoreDefType *getCoreType() const noexcept {

    return std::get_if<std::unique_ptr<CoreDefType>>(&Decl)->get();

  }

  void setCoreType(std::unique_ptr<CoreDefType> &&T) noexcept {

    Decl.emplace<std::unique_ptr<CoreDefType>>(std::move(T));

  }

  const DefType *getType() const noexcept {

    return std::get_if<std::unique_ptr<DefType>>(&Decl)->get();

  }

  void setType(std::unique_ptr<DefType> &&T) noexcept {

    Decl.emplace<std::unique_ptr<DefType>>(std::move(T));

  }

  const Alias &getAlias() const noexcept { return *std::get_if<Alias>(&Decl); }

  void setAlias(Alias &&A) noexcept { Decl.emplace<Alias>(std::move(A)); }

  const ExportDecl &getExport() const noexcept {

    return *std::get_if<ExportDecl>(&Decl);

  }

  void setExport(ExportDecl &&Exp) noexcept {

    Decl.emplace<ExportDecl>(std::move(Exp));

  }

  bool isCoreType() const noexcept {

    return std::holds_alternative<std::unique_ptr<CoreDefType>>(Decl);

  }

  bool isType() const noexcept {

    return std::holds_alternative<std::unique_ptr<DefType>>(Decl);

  }

  bool isAlias() const noexcept { return std::holds_alternative<Alias>(Decl); }

  bool isExportDecl() const noexcept {

    return std::holds_alternative<ExportDecl>(Decl);

  }

private:

  std::variant<std::unique_ptr<CoreDefType>, std::unique_ptr<DefType>, Alias,

               ExportDecl>

      Decl;

};

// componentdecl ::= 0x03 id:<importdecl> => id

//                 | id:<instancedecl>    => id

/// AST Component::ComponentDecl node.

class ComponentDecl {

public:

  const ImportDecl &getImport() const noexcept {

    return *std::get_if<ImportDecl>(&Decl);

  }

  void setImport(ImportDecl &&Imp) noexcept {

    Decl.emplace<ImportDecl>(std::move(Imp));

  }

  const InstanceDecl &getInstance() const noexcept {

    return *std::get_if<InstanceDecl>(&Decl);

  }

  void setInstance(InstanceDecl &&Inst) noexcept {

    Decl.emplace<InstanceDecl>(std::move(Inst));

  }

  bool isImportDecl() const noexcept {

    return std::holds_alternative<ImportDecl>(Decl);

  }

  bool isInstanceDecl() const noexcept {

    return std::holds_alternative<InstanceDecl>(Decl);

  }

private:

  std::variant<ImportDecl, InstanceDecl> Decl;

};

} // namespace Component

} // namespace AST

} // namespace WasmEdge