// 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 <functional>

#include <memory>

#include <string>

#include <utility>

#include <vector>

#include "absl/base/attributes.h"

#include "absl/functional/any_invocable.h"

#include "absl/status/statusor.h"

#include "absl/strings/string_view.h"

#include "absl/types/optional.h"

#include "absl/types/span.h"

#include "common/expr.h"

#include "parser/macro_expr_factory.h"

namespace cel {

// MacroExpander converts the arguments of a function call that matches a

// Macro.

//

// If this is a receiver-style macro, the second argument (optional expr) will

// be engaged. In the case of a global call, it will be `absl::nullopt`.

//

// Should return the replacement subexpression if replacement should occur,

// otherwise absl::nullopt. If `absl::nullopt` is returned, none of the

// arguments including the target must have been modified. Doing so is undefined

// behavior. Otherwise the expander is free to mutate the arguments and either

// include or exclude them from the result.

//

// We use `std::reference_wrapper<Expr>` to be consistent with the fact that we

// do not use raw pointers elsewhere with `Expr` and friends. Ideally we would

// just use `absl::optional<Expr&>`, but that is not currently allowed and our

// `optional_ref<T>` is internal.

using MacroExpander = absl::AnyInvocable<absl::optional<Expr>(

    MacroExprFactory&, absl::optional<std::reference_wrapper<Expr>>,

    absl::Span<Expr>) const>;

// `GlobalMacroExpander` is a `MacroExpander` for global macros.

using GlobalMacroExpander = absl::AnyInvocable<absl::optional<Expr>(

    MacroExprFactory&, absl::Span<Expr>) const>;

// `ReceiverMacroExpander` is a `MacroExpander` for receiver-style macros.

using ReceiverMacroExpander = absl::AnyInvocable<absl::optional<Expr>(

    MacroExprFactory&, Expr&, absl::Span<Expr>) const>;

// 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,

                                      GlobalMacroExpander expander);

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

                                            GlobalMacroExpander expander);

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

                                        size_t argument_count,

                                        ReceiverMacroExpander expander);

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

                                              ReceiverMacroExpander expander);

  Macro(const Macro&) = default;

  Macro(Macro&&) = default;

  Macro& operator=(const Macro&) = default;

  Macro& operator=(Macro&&) = default;

  // Function name to match.

  absl::string_view function() const ABSL_ATTRIBUTE_LIFETIME_BOUND {

    return rep_->function;

  }

  // 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 rep_->arg_count; }

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

  bool is_receiver_style() const { return rep_->receiver_style; }

  bool is_variadic() const { return rep_->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 ABSL_ATTRIBUTE_LIFETIME_BOUND {

    return rep_->key;

  }

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

  // parsed call signature.

  const MacroExpander& expander() const ABSL_ATTRIBUTE_LIFETIME_BOUND {

    return rep_->expander;

  }

  ABSL_MUST_USE_RESULT absl::optional<Expr> Expand(

      MacroExprFactory& factory,

      absl::optional<std::reference_wrapper<Expr>> target,

      absl::Span<Expr> arguments) const {

    return (expander())(factory, target, arguments);

  }

  friend void swap(Macro& lhs, Macro& rhs) noexcept {

    using std::swap;

    swap(lhs.rep_, rhs.rep_);

  }

  ABSL_DEPRECATED("use MacroRegistry and RegisterStandardMacros")

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

 private:

  struct Rep final {

    Rep(std::string function, std::string key, size_t arg_count,

        MacroExpander expander, bool receiver_style, bool var_arg_style)

        : function(std::move(function)),

          key(std::move(key)),

          arg_count(arg_count),

          expander(std::move(expander)),

          receiver_style(receiver_style),

          var_arg_style(var_arg_style) {}

    std::string function;

    std::string key;

    size_t arg_count;

    MacroExpander expander;

    bool receiver_style;

    bool var_arg_style;

  };

  static std::string Key(absl::string_view name, size_t argument_count,

                         bool receiver_style, bool var_arg_style);

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

                                    size_t argument_count,

                                    MacroExpander expander, bool receiver_style,

                                    bool var_arg_style);

  explicit Macro(std::shared_ptr<const Rep> rep) : rep_(std::move(rep)) {}

  std::shared_ptr<const Rep> rep_;

};

// The macro "has(m.f)" which tests the presence of a field, avoiding the

// need to specify the field as a string.

const Macro& HasMacro();

// The macro "range.all(var, predicate)", which is true if for all

// elements in range the predicate holds.

const Macro& AllMacro();

// The macro "range.exists(var, predicate)", which is true if for at least

// one element in range the predicate holds.

const Macro& ExistsMacro();

// The macro "range.exists_one(var, predicate)", which is true if for

// exactly one element in range the predicate holds.

const Macro& ExistsOneMacro();

// The macro "range.map(var, function)", applies the function to the vars

// in the range.

const Macro& Map2Macro();

// The macro "range.map(var, predicate, function)", applies the function

// to the vars in the range for which the predicate holds true. The other

// variables are filtered out.

const Macro& Map3Macro();

// The macro "range.filter(var, predicate)", filters out the variables for

// which the predicate is false.

const Macro& FilterMacro();

// `OptMapMacro`

//

// Apply a transformation to the optional's underlying value if it is not empty

// and return an optional typed result based on the transformation. The

// transformation expression type must return a type T which is wrapped into

// an optional.

//

//  msg.?elements.optMap(e, e.size()).orValue(0)

const Macro& OptMapMacro();

// `OptFlatMapMacro`

//

// Apply a transformation to the optional's underlying value if it is not empty

// and return the result. The transform expression must return an optional(T)

// rather than type T. This can be useful when dealing with zero values and

// conditionally generating an empty or non-empty result in ways which cannot

// be expressed with `optMap`.

//

//  msg.?elements.optFlatMap(e, e[?0]) // return the first element if present.

const Macro& OptFlatMapMacro();

}  // namespace cel

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

using MacroExpander = cel::MacroExpander;

using Macro = cel::Macro;

}  // namespace google::api::expr::parser

#endif  // THIRD_PARTY_CEL_CPP_PARSER_MACRO_H_