// SPDX-License-Identifier: LGPL-2.1+

#include "nm-default.h"

#include "nm-libnm-aux.h"

/*****************************************************************************/

NMClient *
nmc_client_new_async_valist (GCancellable *cancellable,
                             GAsyncReadyCallback callback,
                             gpointer user_data,
                             const char *first_property_name,
                             va_list ap)
{
	NMClient *nmc;

	nmc = NM_CLIENT (g_object_new_valist (NM_TYPE_CLIENT, first_property_name, ap));
	g_async_initable_init_async (G_ASYNC_INITABLE (nmc),
	                             G_PRIORITY_DEFAULT,
	                             cancellable,
	                             callback,
	                             user_data);
	return nmc;
}

NMClient *
nmc_client_new_async (GCancellable *cancellable,
                      GAsyncReadyCallback callback,
                      gpointer user_data,
                      const char *first_property_name,
                      ...)
{
	NMClient *nmc;
	va_list ap;

	va_start (ap, first_property_name);
	nmc = nmc_client_new_async_valist (cancellable,
	                                   callback,
	                                   user_data,
	                                   first_property_name,
	                                   ap);
	va_end (ap);
	return nmc;
}

/*****************************************************************************/

typedef struct {
	GMainLoop *main_loop;
	NMClient *nmc;
	GError *error;
} ClientCreateData;

static void
_nmc_client_new_waitsync_cb (GObject *source_object,
                             GAsyncResult *result,
                             gpointer user_data)
{
	ClientCreateData *data = user_data;

	g_async_initable_init_finish (G_ASYNC_INITABLE (source_object),
	                              result,
	                              &data->error);
	g_main_loop_quit (data->main_loop);
}

/**
 * nmc_client_new:
 * @cancellable: the cancellable to abort the creation.
 * @out_nmc: (out): (transfer full): if give, transfers a reference
 *   to the NMClient instance. Note that this never fails to create
 *   the NMClient GObject, but depending on the return value,
 *   the instance was successfully initialized or not.
 * @error: the error if creation fails.
 * @first_property_name: the name of the first property
 * @...: the value of the first property, followed optionally by more
 *  name/value pairs, followed by %NULL
 *
 * Returns: %TRUE, if the client was successfully initalized.
 *
 * This uses nm_client_new_async() to create a NMClient instance,
 * but it iterates the current GMainContext until the client is
 * ready. As such, it waits for the client creation to complete
 * (like sync nm_client_new()) but it iterates the caller's GMainContext
 * (unlike sync nm_client_new()). This is often preferable, because
 * sync nm_client_new() needs to create an additional internal GMainContext
 * that it can iterate instead. That has a performance overhead that
 * is often unnecessary.
 */
gboolean
nmc_client_new_waitsync (GCancellable *cancellable,
                         NMClient **out_nmc,
                         GError **error,
                         const char *first_property_name,
                         ...)
{
	gs_unref_object NMClient *nmc = NULL;
	nm_auto_unref_gmainloop GMainLoop *main_loop = g_main_loop_new (g_main_context_get_thread_default (), FALSE);
	ClientCreateData data = {
		.main_loop = main_loop,
	};
	va_list ap;

#if NM_MORE_ASSERTS > 10
	/* The sync initialization of NMClient is generally a bad idea, because it
	 * brings the overhead of an additional GMainContext. Anyway, since our own
	 * code no longer uses that, we hardly test those code paths. But they should
	 * work just the same. Randomly use instead the sync initialization in a debug
	 * build... */
	if ((g_random_int () % 2) == 0) {
		gboolean success;

		va_start (ap, first_property_name);
		nmc = NM_CLIENT (g_object_new_valist (NM_TYPE_CLIENT, first_property_name, ap));
		va_end (ap);

		/* iterate the context at least once, just so that the behavior from POV of the
		 * caller is roughly the same. */
		g_main_context_iteration (nm_client_get_main_context (nmc), FALSE);

		success = g_initable_init (G_INITABLE (nmc),
		                           cancellable,
		                           error);
		NM_SET_OUT (out_nmc, g_steal_pointer (&nmc));
		return success;
	}
#endif

	va_start (ap, first_property_name);
	nmc = nmc_client_new_async_valist (cancellable,
	                                   _nmc_client_new_waitsync_cb,
	                                   &data,
	                                   first_property_name,
	                                   ap);
	va_end (ap);

	g_main_loop_run (main_loop);

	NM_SET_OUT (out_nmc, g_steal_pointer (&nmc));
	if (data.error) {
		g_propagate_error (error, data.error);
		return FALSE;
	}
	return TRUE;
}