// Copyright 2021 Google LLC

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//     https://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

#ifndef THIRD_PARTY_CEL_CPP_PARSER_MACRO_H_

#define THIRD_PARTY_CEL_CPP_PARSER_MACRO_H_

#include <cstddef>

#include <cstdint>

#include <functional>

#include <memory>

#include <string>

#include <utility>

#include "google/api/expr/v1alpha1/syntax.pb.h"

#include "absl/base/attributes.h"

#include "absl/status/statusor.h"

#include "absl/strings/str_cat.h"

#include "absl/strings/string_view.h"

namespace google::api::expr::parser {

class SourceFactory;

}

namespace cel {

using SourceFactory = google::api::expr::parser::SourceFactory;

// MacroExpander converts the target and args of a function call that matches a

// Macro.

//

// Note: when the Macros.IsReceiverStyle() is true, the target argument will

// be Expr::default_instance().

using MacroExpander = std::function<google::api::expr::v1alpha1::Expr(

    const std::shared_ptr<SourceFactory>& sf, int64_t macro_id,

    const google::api::expr::v1alpha1::Expr&,

    // This should be absl::Span instead of std::vector.

    const std::vector<google::api::expr::v1alpha1::Expr>&)>;

// Macro interface for describing the function signature to match and the

// MacroExpander to apply.

//

// Note: when a Macro should apply to multiple overloads (based on arg count) of

// a given function, a Macro should be created per arg-count.

class Macro final {

 public:

  static absl::StatusOr<Macro> Global(absl::string_view name,

                                      size_t argument_count,

                                      MacroExpander expander);

  static absl::StatusOr<Macro> GlobalVarArg(absl::string_view name,

                                            MacroExpander expander);

  static absl::StatusOr<Macro> Receiver(absl::string_view name,

                                        size_t argument_count,

                                        MacroExpander expander);

  static absl::StatusOr<Macro> ReceiverVarArg(absl::string_view name,

                                              MacroExpander expander);

  // Create a Macro for a global function with the specified number of arguments

  ABSL_DEPRECATED("Use static factory methods instead.")

  Macro(absl::string_view function, size_t arg_count, MacroExpander expander,

        bool receiver_style = false)

      : key_(absl::StrCat(function, ":", arg_count, ":",

                          receiver_style ? "true" : "false")),

        arg_count_(arg_count),

        expander_(std::make_shared<MacroExpander>(std::move(expander))),

        receiver_style_(receiver_style),

        var_arg_style_(false) {}

  ABSL_DEPRECATED("Use static factory methods instead.")

  Macro(absl::string_view function, MacroExpander expander,

        bool receiver_style = false)

      : key_(absl::StrCat(function, ":*:", receiver_style ? "true" : "false")),

        arg_count_(0),

        expander_(std::make_shared<MacroExpander>(std::move(expander))),

        receiver_style_(receiver_style),

        var_arg_style_(true) {}

  // Function name to match.

  absl::string_view function() const { return key().substr(0, key_.find(':')); }

  // argument_count() for the function call.

  //

  // When the macro is a var-arg style macro, the return value will be zero, but

  // the MacroKey will contain a `*` where the arg count would have been.

  size_t argument_count() const { return arg_count_; }

  // is_receiver_style returns true if the macro matches a receiver style call.

  bool is_receiver_style() const { return receiver_style_; }

  bool is_variadic() const { return var_arg_style_; }

  // key() returns the macro signatures accepted by this macro.

  //

  // Format: `<function>:<arg-count>:<is-receiver>`.

  //

  // When the macros is a var-arg style macro, the `arg-count` value is

  // represented as a `*`.

  absl::string_view key() const { return key_; }

  // Expander returns the MacroExpander to apply when the macro key matches the

  // parsed call signature.

  const MacroExpander& expander() const { return *expander_; }

  google::api::expr::v1alpha1::Expr Expand(

      const std::shared_ptr<SourceFactory>& sf, int64_t macro_id,

      const google::api::expr::v1alpha1::Expr& target,

      const std::vector<google::api::expr::v1alpha1::Expr>& args) const {

    return (expander())(sf, macro_id, target, args);

  }

  static std::vector<Macro> AllMacros();

 private:

  std::string key_;

  size_t arg_count_;

  std::shared_ptr<MacroExpander> expander_;

  bool receiver_style_;

  bool var_arg_style_;

};

}  // namespace cel

namespace google {

namespace api {

namespace expr {

namespace parser {

using MacroExpander = cel::MacroExpander;

using Macro = cel::Macro;

}  // namespace parser

}  // namespace expr

}  // namespace api

}  // namespace google

#endif  // THIRD_PARTY_CEL_CPP_PARSER_MACRO_H_