251UniValue OpenRPCResultSchema(const RPCResult& result);
252
253UniValue MakeObject(std::initializer_list<std::pair<std::string, UniValue>> entries)
254{
255    UniValue obj{UniValue::VOBJ};
256    for (const auto& [key, value] : entries) {
257        obj.pushKV(key, value);
258    }
259    return obj;
260}
261
262void PushUniqueSchema(UniValue& schemas, std::unordered_set<std::string>& seen, UniValue schema)
263{
264    const std::string serialized{schema.write()};
265    if (seen.insert(serialized).second) schemas.push_back(std::move(schema));
266}
267
268// NOLINTNEXTLINE(misc-no-recursion)
269UniValue DedupArrayItemsSchema(std::span<const RPCArg> inner, bool include_hidden, bool in_skip_type_check)
270{
271    if (inner.empty()) return UniValue{UniValue::VOBJ};
272    if (inner.size() == 1) return OpenRPCArgSchema(inner.front(), include_hidden, in_skip_type_check);
273
274    UniValue one_of{UniValue::VARR};
275    std::unordered_set<std::string> seen;
276    for (const auto& item : inner) {
277        PushUniqueSchema(one_of, seen, OpenRPCArgSchema(item, include_hidden, in_skip_type_check));
278    }
279
280    if (one_of.size() == 1) return one_of[0];
281
282    UniValue items{UniValue::VOBJ};
283    items.pushKV(in_skip_type_check ? "anyOf" : "oneOf", std::move(one_of));
284    return items;
285}
286
287// NOLINTNEXTLINE(misc-no-recursion)
288UniValue DedupArrayItemsSchema(std::span<const RPCResult> inner)
289{
290    if (inner.empty()) return UniValue{UniValue::VOBJ};
291    if (inner.size() == 1) return OpenRPCResultSchema(inner.front());
292
293    UniValue one_of{UniValue::VARR};
294    std::unordered_set<std::string> seen;
295    for (const auto& item : inner) {
296        PushUniqueSchema(one_of, seen, OpenRPCResultSchema(item));
297    }
298
299    if (one_of.size() == 1) return one_of[0];
300
301    UniValue items{UniValue::VOBJ};
302    items.pushKV("oneOf", std::move(one_of));
303    return items;
304}
305
306void ApplyTypeStrOverride(UniValue& schema, const RPCArg& arg)
307{
308    if (arg.m_opts.type_str.size() != 2) return;
309    const std::string& type_label{arg.m_opts.type_str[1]};
310    if (type_label.empty()) return;
311
312    static const std::unordered_set<std::string> number_or_string{
313        "integer / string",
314        "string or numeric",
315    };
316    if (number_or_string.contains(type_label)) {
317        UniValue one_of{UniValue::VARR};
318        one_of.push_back(MakeObject({{"type", "integer"}}));
319        one_of.push_back(MakeObject({{"type", "string"}}));
320        schema = UniValue{UniValue::VOBJ};
321        schema.pushKV("oneOf", std::move(one_of));
322    } else {
323        schema.pushKV("x-bitcoin-type-override", type_label);
324    }
325}
326
327void ApplyArgFallback(UniValue& schema, const RPCArg& arg)
328{
329    std::visit(util::Overloaded{
330                   [&](const RPCArg::Default& def) { schema.pushKV("default", def); },
331                   [&](const RPCArg::DefaultHint& hint) { schema.pushKV("x-bitcoin-default-hint", hint); },
332                   [](const RPCArg::Optional&) {},
333               },
334               arg.m_fallback);
335}
336
337// NOLINTNEXTLINE(misc-no-recursion)
338UniValue OpenRPCArgSchema(const RPCArg& arg, bool include_hidden, bool in_skip_type_check)
339{
340    UniValue schema{UniValue::VOBJ};
341    if (arg.m_opts.skip_type_check) {
342        ApplyTypeStrOverride(schema, arg);
343        if (schema.empty() && arg.m_type == RPCArg::Type::ARR) {
344            UniValue items{UniValue::VOBJ};
345            items.pushKV("type", "array");
346            items.pushKV("items", DedupArrayItemsSchema(arg.m_inner, include_hidden, /*in_skip_type_check=*/true));
347
348            UniValue one_of{UniValue::VARR};
349            one_of.push_back(std::move(items));
350            one_of.push_back(MakeObject({{"type", "object"}}));
351            schema.pushKV("oneOf", std::move(one_of));
352        }
353        ApplyArgFallback(schema, arg);
354        return schema;
355    }
356
357    switch (arg.m_type) {
358    case RPCArg::Type::STR:
359        schema = MakeObject({{"type", "string"}});
360        break;
361    case RPCArg::Type::STR_HEX:
362        schema = MakeObject({{"type", "string"}, {"pattern", "^([0-9a-fA-F]{2})*$"}});
363        break;
364    case RPCArg::Type::NUM:
365        schema = MakeObject({{"type", "number"}});
366        break;
367    case RPCArg::Type::BOOL:
368        schema = MakeObject({{"type", "boolean"}});
369        break;
370    case RPCArg::Type::AMOUNT: {
371        UniValue one_of{UniValue::VARR};
372        one_of.push_back(MakeObject({{"type", "number"}}));
373        one_of.push_back(MakeObject({{"type", "string"}}));
374        schema.pushKV("oneOf", std::move(one_of));
375        break;
376    }
377    case RPCArg::Type::RANGE: {
378        UniValue items{UniValue::VARR};
379        items.push_back(MakeObject({{"type", "number"}}));
380        items.push_back(MakeObject({{"type", "number"}}));
381        UniValue range_schema{UniValue::VOBJ};
382        range_schema.pushKV("type", "array");
383        range_schema.pushKV("items", std::move(items));
384        range_schema.pushKV("additionalItems", false);
385        range_schema.pushKV("minItems", 2);
386        range_schema.pushKV("maxItems", 2);
387        UniValue one_of{UniValue::VARR};
388        one_of.push_back(MakeObject({{"type", "number"}}));
389        one_of.push_back(std::move(range_schema));
390        schema.pushKV("oneOf", std::move(one_of));
391        break;
392    }
393    case RPCArg::Type::ARR: {
394        UniValue items{DedupArrayItemsSchema(arg.m_inner, include_hidden, in_skip_type_check)};
395        schema.pushKV("type", "array");
396        schema.pushKV("items", std::move(items));
397        break;
398    }
399    case RPCArg::Type::OBJ:
400    case RPCArg::Type::OBJ_NAMED_PARAMS: {
401        UniValue properties{UniValue::VOBJ};
402        UniValue required{UniValue::VARR};
403        for (const auto& inner : arg.m_inner) {
404            if (!include_hidden && inner.m_opts.hidden) continue;
405            UniValue prop{OpenRPCArgSchema(inner, include_hidden, in_skip_type_check)};
406            if (!inner.m_description.empty()) prop.pushKV("description", inner.m_description);
407            if (inner.m_opts.placeholder) prop.pushKV("x-bitcoin-placeholder", true);
408            if (inner.m_opts.also_positional) prop.pushKV("x-bitcoin-also-positional", true);
409            properties.pushKV(inner.GetFirstName(), std::move(prop));
410            if (!inner.IsOptional()) required.push_back(inner.GetFirstName());
411        }
412        schema.pushKV("type", "object");
413        schema.pushKV("properties", std::move(properties));
414        schema.pushKV("additionalProperties", false);
415        if (!required.empty()) schema.pushKV("required", std::move(required));
416        break;
417    }
418    case RPCArg::Type::OBJ_USER_KEYS: {
419        schema.pushKV("type", "object");
420        if (!arg.m_inner.empty()) {
421            schema.pushKV("additionalProperties", OpenRPCArgSchema(arg.m_inner[0], include_hidden, in_skip_type_check));
422            if (!arg.m_inner[0].m_description.empty()) {
423                schema.pushKV("description", arg.m_inner[0].m_description);
424            }
425        } else {
426            schema.pushKV("additionalProperties", true);
427        }
428        break;
429    }
430    } // no default case, so the compiler can warn about missing cases
431    ApplyTypeStrOverride(schema, arg);
432    ApplyArgFallback(schema, arg);
433    return schema;
434}
435
436// NOLINTNEXTLINE(misc-no-recursion)
437UniValue OpenRPCResultSchema(const RPCResult& result)
438{
439    if (result.m_opts.skip_type_check) {
440        RPCResultOptions opts{result.m_opts};
441        opts.skip_type_check = false;
442        if (result.m_type == RPCResult::Type::OBJ) {
443            UniValue obj_schema{OpenRPCResultSchema(RPCResult{result, std::move(opts)})};
444            if (result.m_key_name.empty()) return obj_schema;
445
446            UniValue one_of{UniValue::VARR};
447            one_of.push_back(std::move(obj_schema));
448            one_of.push_back(MakeObject({{"const", false}}));
449            UniValue schema{UniValue::VOBJ};
450            schema.pushKV("oneOf", std::move(one_of));
451            return schema;
452        }
453        if (result.m_type == RPCResult::Type::ARR) return OpenRPCResultSchema(RPCResult{result, std::move(opts)});
454        return UniValue{UniValue::VOBJ};
455    }
456
457    switch (result.m_type) {
458    case RPCResult::Type::STR:
459        return MakeObject({{"type", "string"}});
460    case RPCResult::Type::STR_AMOUNT:
461        return MakeObject({{"type", "number"}, {"x-bitcoin-unit", "amount"}});
462    case RPCResult::Type::STR_HEX:
463        return MakeObject({{"type", "string"}, {"pattern", "^([0-9a-fA-F]{2})*$"}});
464    case RPCResult::Type::NUM:
465        return MakeObject({{"type", "number"}});
466    case RPCResult::Type::NUM_TIME: {
467        UniValue schema{UniValue::VOBJ};
468        schema.pushKV("type", "number");
469        schema.pushKV("x-bitcoin-unit", "unix-time");
470        return schema;
471    }
472    case RPCResult::Type::BOOL:
473        return MakeObject({{"type", "boolean"}});
474    case RPCResult::Type::NONE:
475        return MakeObject({{"type", "null"}});
476    case RPCResult::Type::ARR: {
477        UniValue items{DedupArrayItemsSchema(result.m_inner)};
478        UniValue schema{UniValue::VOBJ};
479        schema.pushKV("type", "array");
480        schema.pushKV("items", std::move(items));
481        return schema;
482    }
483    case RPCResult::Type::ARR_FIXED: {
484        UniValue items{UniValue::VARR};
485        for (const auto& inner : result.m_inner) {
486            items.push_back(OpenRPCResultSchema(inner));
487        }
488        UniValue schema{UniValue::VOBJ};
489        schema.pushKV("type", "array");
490        schema.pushKV("items", std::move(items));
491        schema.pushKV("additionalItems", false);
492        schema.pushKV("minItems", uint64_t(result.m_inner.size()));
493        schema.pushKV("maxItems", uint64_t(result.m_inner.size()));
494        return schema;
495    }
496    case RPCResult::Type::OBJ: {
497        UniValue properties{UniValue::VOBJ};
498        UniValue required{UniValue::VARR};
499        for (const auto& inner : result.m_inner) {
500            if (inner.m_key_name.empty()) continue;