// Copyright 2024 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_PARSER_INTERFACE_H_

#define THIRD_PARTY_CEL_CPP_PARSER_PARSER_INTERFACE_H_

#include <memory>

#include <string>

#include <utility>

#include <vector>

#include "absl/base/nullability.h"

#include "absl/functional/any_invocable.h"

#include "absl/status/status.h"

#include "absl/status/statusor.h"

#include "absl/strings/string_view.h"

#include "common/ast.h"

#include "common/source.h"

#include "parser/macro.h"

#include "parser/options.h"

namespace cel {

class Parser;

class ParserBuilder;

// Callable for configuring a ParserBuilder.

using ParserBuilderConfigurer =

    absl::AnyInvocable<absl::Status(ParserBuilder&) const>;

struct ParserLibrary {

  // Optional identifier to avoid collisions re-adding the same macros. If

  // empty, it is not considered for collision detection.

  std::string id;

  ParserBuilderConfigurer configure;

};

// Declares a subset of a parser library.

struct ParserLibrarySubset {

  // The id of the library to subset. Only one subset can be applied per

  // library id.

  //

  // Must be non-empty.

  std::string library_id;

  using MacroPredicate = absl::AnyInvocable<bool(const Macro&) const>;

  MacroPredicate should_include_macro;

};

// Interface for building a CEL parser, see comments on `Parser` below.

class ParserBuilder {

 public:

  virtual ~ParserBuilder() = default;

  // Returns the (mutable) current parser options.

  virtual ParserOptions& GetOptions() = 0;

  // Adds a macro to the parser.

  // Standard macros should be automatically added based on parser options.

  virtual absl::Status AddMacro(const cel::Macro& macro) = 0;

  virtual absl::Status AddLibrary(ParserLibrary library) = 0;

  virtual absl::Status AddLibrarySubset(ParserLibrarySubset subset) = 0;

  // Builds a new parser instance, may error if incompatible macros are added.

  virtual absl::StatusOr<std::unique_ptr<Parser>> Build() = 0;

};

// Information about a parse failure.

class ParseIssue {

 public:

  explicit ParseIssue(std::string message) : message_(std::move(message)) {}

  ParseIssue(SourceLocation location, std::string message)

      : location_(location), message_(std::move(message)) {}

  ParseIssue(const ParseIssue& other) = default;

  ParseIssue& operator=(const ParseIssue& other) = default;

  ParseIssue(ParseIssue&& other) = default;

  ParseIssue& operator=(ParseIssue&& other) = default;

  SourceLocation location() const { return location_; }

  absl::string_view message() const { return message_; }

 private:

  SourceLocation location_;

  std::string message_;

};

// Interface for stateful CEL parser objects for use with a `Compiler`

// (bundled parse and type check). This is not needed for most users:

// prefer using the free functions in `parser.h` for more flexibility.

class Parser {

 public:

  virtual ~Parser() = default;

  // Parses the given source into a CEL AST.

  absl::StatusOr<std::unique_ptr<cel::Ast>> Parse(

      const cel::Source& source) const;

  // Parses the given source into a CEL AST, collecting parse errors in

  // `issues`. If `issues` is non-null, it will be cleared and all parse

  // issues will be appended to it.

  absl::StatusOr<std::unique_ptr<cel::Ast>> Parse(

      const cel::Source& source, std::vector<ParseIssue>* issues) const;

  // Returns a builder initialized with the configuration of this parser.

  virtual std::unique_ptr<ParserBuilder> ToBuilder() const = 0;

 protected:

  virtual absl::StatusOr<std::unique_ptr<cel::Ast>> ParseImpl(

      const cel::Source& source,

      std::vector<ParseIssue>* absl_nullable parse_issues) const = 0;

};

inline absl::StatusOr<std::unique_ptr<cel::Ast>> Parser::Parse(

    const cel::Source& source) const {

  return ParseImpl(source, nullptr);

}

inline absl::StatusOr<std::unique_ptr<cel::Ast>> Parser::Parse(

    const cel::Source& source, std::vector<ParseIssue>* issues) const {

  if (issues != nullptr) issues->clear();

  return ParseImpl(source, issues);

}

}  // namespace cel

#endif  // THIRD_PARTY_CEL_CPP_PARSER_PARSER_INTERFACE_H_