// Copyright 2026 Memgraph Ltd.

//

// Use of this software is governed by the Business Source License

// included in the file licenses/BSL.txt; by using this file, you agree to be bound by the terms of the Business Source

// License, and you may not use this file except in compliance with the Business Source License.

//

// As of the Change Date specified in that file, in accordance with

// the Business Source License, use of this software will be governed

// by the Apache License, Version 2.0, included in the file

// licenses/APL.txt.

#include <mgp.hpp>

#include <string>

namespace Mgps {

constexpr std::string_view kProcedureValidate = "validate";

constexpr std::string_view kParameterPredicate = "predicate";

constexpr std::string_view kParameterMessage = "message";

constexpr std::string_view kParameterParams = "params";

void Validate(mgp_list *args, mgp_graph * /*memgraph_graph*/, mgp_result *result, mgp_memory *memory) {

mgp::MemoryDispatcherGuard guard{memory};

const auto arguments = mgp::List(args);

const auto predicate = arguments[0].ValueBool();

if (!predicate) {

return;

}

auto message = std::string(arguments[1].ValueString());

const auto params = arguments[2].ValueList();

// Replace format specifiers: %d (int), %f (double), %s (string)

std::size_t pos = 0;

for (const auto &param : params) {

pos = message.find('%', pos);

if (pos == std::string::npos || pos + 1 >= message.size()) break;

const char spec = message[pos + 1];

if (!std::isalpha(static_cast<unsigned char>(spec))) {

++pos;

continue;

}

std::string replacement;

switch (spec) {

case 'd':

replacement = std::to_string(param.ValueInt());

break;

case 'f':

replacement = std::to_string(param.ValueDouble());

break;

case 's':

replacement = std::string(param.ValueString());

break;

default:

static_cast<void>(

mgp_result_set_error_msg(result, ("Unsupported format specifier: %" + std::string(1, spec)).c_str()));

return;

}

message.replace(pos, 2, replacement);

pos += replacement.size();

}

static_cast<void>(mgp_result_set_error_msg(result, message.c_str()));

}

} // namespace Mgps

extern "C" int mgp_init_module(struct mgp_module *module, struct mgp_memory *memory) {

try {

mgp::MemoryDispatcherGuard guard{memory};

AddProcedure(Mgps::Validate,

Mgps::kProcedureValidate,

mgp::ProcedureType::Read,

{mgp::Parameter(Mgps::kParameterPredicate, mgp::Type::Bool),

mgp::Parameter(Mgps::kParameterMessage, mgp::Type::String),

mgp::Parameter(Mgps::kParameterParams, {mgp::Type::List, mgp::Type::Any})},

{}, // No return values - void procedure

module,

memory);

} catch (const std::exception &e) {

return 1;

}

return 0;

}

extern "C" int mgp_shutdown_module() { return 0; }