#include "testutil/expr_printer.h"

#include <string>

#include "absl/strings/str_format.h"

#include "common/escaping.h"

namespace google {

namespace api {

namespace expr {

namespace testutil {

namespace {

using ::google::api::expr::v1alpha1::Expr;

class EmptyAdorner : public ExpressionAdorner {

public:

~EmptyAdorner() {}

std::string adorn(const Expr& e) const { return ""; }

std::string adorn(const Expr::CreateStruct::Entry& e) const {

return "";

}

};

const EmptyAdorner the_empty_adorner;

class Writer {

public:

Writer(const ExpressionAdorner& adorner)

: adorner_(adorner), line_start_(true), indent_(0) {}

void appendExpr(const Expr& e) {

switch (e.expr_kind_case()) {

case Expr::kConstExpr:

append(formatLiteral(e.const_expr()));

break;

case Expr::kIdentExpr:

append(e.ident_expr().name());

break;

case Expr::kSelectExpr:

appendSelect(e.select_expr());

break;

case Expr::kCallExpr:

appendCall(e.call_expr());

break;

case Expr::kListExpr:

appendList(e.list_expr());

break;

case Expr::kStructExpr:

appendStruct(e.struct_expr());

break;

case Expr::kComprehensionExpr:

appendComprehension(e.comprehension_expr());

break;

default:

break;

}

appendAdorn(e);

}

void appendSelect(const Expr::Select& sel) {

appendExpr(sel.operand());

append(".");

append(sel.field());

if (sel.test_only()) {

append("~test-only~");

}

}

void appendCall(const Expr::Call& call) {

if (call.has_target()) {

appendExpr(call.target());

s_ += ".";

}

append(call.function());

append("(");

if (call.args_size() > 0) {

addIndent();

appendLine();

for (int i = 0; i < call.args_size(); ++i) {

const auto& arg = call.args(i);

if (i > 0) {

append(",");

appendLine();

}

appendExpr(arg);

}

removeIndent();

appendLine();

}

append(")");

}

void appendList(const Expr::CreateList& list) {

append("[");

if (list.elements_size() > 0) {

appendLine();

addIndent();

for (int i = 0; i < list.elements_size(); ++i) {

const auto& elem = list.elements(i);

if (i > 0) {

append(",");

appendLine();

}

appendExpr(elem);

}

removeIndent();

appendLine();

}

append("]");

}

void appendStruct(const Expr::CreateStruct& obj) {

if (obj.message_name().empty()) {

appendMap(obj);

} else {

appendObject(obj);

}

}

void appendMap(const Expr::CreateStruct& obj) {

append("{");

if (obj.entries_size() > 0) {

appendLine();

addIndent();

for (int i = 0; i < obj.entries_size(); ++i) {

const auto& entry = obj.entries(i);

if (i > 0) {

append(",");

appendLine();

}

appendExpr(entry.map_key());

append(":");

appendExpr(entry.value());

appendAdorn(entry);

}

removeIndent();

appendLine();

}

append("}");

}

void appendObject(const Expr::CreateStruct& obj) {

append(obj.message_name());

append("{");

if (obj.entries_size() > 0) {

appendLine();

addIndent();

for (int i = 0; i < obj.entries_size(); ++i) {

const auto& entry = obj.entries(i);

if (i > 0) {

append(",");

appendLine();

}

append(entry.field_key());

append(":");

appendExpr(entry.value());

appendAdorn(entry);

}

removeIndent();

appendLine();

}

append("}");

}

void appendComprehension(const Expr::Comprehension& comprehension) {

append("__comprehension__(");

addIndent();

appendLine();

append("// Variable");

appendLine();

append(comprehension.iter_var());

append(",");

appendLine();

append("// Target");

appendLine();

appendExpr(comprehension.iter_range());

append(",");

appendLine();

append("// Accumulator");

appendLine();

append(comprehension.accu_var());

append(",");

appendLine();

append("// Init");

appendLine();

appendExpr(comprehension.accu_init());

append(",");

appendLine();

append("// LoopCondition");

appendLine();

appendExpr(comprehension.loop_condition());

append(",");

appendLine();

append("// LoopStep");

appendLine();

appendExpr(comprehension.loop_step());

append(",");

appendLine();

append("// Result");

appendLine();

appendExpr(comprehension.result());

append(")");

removeIndent();

}

void appendAdorn(const Expr& e) { append(adorner_.adorn(e)); }

void appendAdorn(const Expr::CreateStruct::Entry& e) {

append(adorner_.adorn(e));

}

void append(const std::string& s) {

if (line_start_) {

line_start_ = false;

for (int i = 0; i < indent_; ++i) {

s_ += " ";

}

}

s_ += s;

}

void appendLine() {

s_ += "\n";

line_start_ = true;

}

void addIndent() { indent_ += 1; }

void removeIndent() {

if (indent_ > 0) {

indent_ -= 1;

}

}

std::string formatLiteral(const google::api::expr::v1alpha1::Constant& c) {

switch (c.constant_kind_case()) {

case google::api::expr::v1alpha1::Constant::kBoolValue:

return absl::StrFormat("%s", c.bool_value() ? "true" : "false");

case google::api::expr::v1alpha1::Constant::kBytesValue:

return absl::StrFormat("b\"%s\"", c.bytes_value());

case google::api::expr::v1alpha1::Constant::kDoubleValue: {

std::string s = absl::StrFormat("%f", c.double_value());

// remove trailing zeros, i.e., convert 1.600000 to just 1.6 without

// forcing a specific precision. There seems to be no flag to get this

// directly from absl::StrFormat.

auto idx = std::find_if_not(s.rbegin(), s.rend(),

[](const char c) { return c == '0'; });

s.erase(idx.base(), s.end());

return s;

}

case google::api::expr::v1alpha1::Constant::kInt64Value:

return absl::StrFormat("%d", c.int64_value());

case google::api::expr::v1alpha1::Constant::kStringValue:

return parser::escapeAndQuote(c.string_value());

case google::api::expr::v1alpha1::Constant::kUint64Value:

return absl::StrFormat("%uu", c.uint64_value());

case google::api::expr::v1alpha1::Constant::kNullValue:

return "null";

default:

return "<<ERROR>>";

}

}

std::string print(const Expr& expr) {

appendExpr(expr);

return s_;

}

private:

std::string s_;

const ExpressionAdorner& adorner_;

bool line_start_;

int indent_;

};

} // namespace

const ExpressionAdorner& empty_adorner() {

return the_empty_adorner;

}

std::string ExprPrinter::print(const Expr& expr) const {

Writer w(adorner_);

return w.print(expr);

}

} // namespace testutil

} // namespace expr

} // namespace api

} // namespace google