/*
 *
 *  Connection Manager
 *
 *  Copyright (C) 2015  Intel Corporation. All rights reserved.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>
#include <string.h>
#include <glib.h>
#include <errno.h>
#include <stdbool.h>
#include <dbus/dbus.h>

#include <gdbus.h>
#include <connman/dbus.h>

static DBusConnection *connection;
static GMainLoop *main_loop;
static int timeout = 0;
static int exit_value = 0;

static gboolean option_version = FALSE;
static gchar *option_interface = NULL;
static gchar *option_ignore = NULL;
static gint option_timeout = 120;

struct devices {
	char **interface;
	char **ignore;
};

static GOptionEntry options[] = {
	{ "interface", 'i', 0, G_OPTION_ARG_STRING, &option_interface,
	  "Specify networking device or interface", "DEV" },
	{ "ignore", 'I', 0, G_OPTION_ARG_STRING, &option_ignore,
	  "Specify networking device or interface to ignore", "DEV" },
	{ "timeout", 0, 0, G_OPTION_ARG_INT, &option_timeout,
	  "Time to wait for network going online. Default is 120 seconds.",
	  "seconds" },
	{ "version", 'v', 0, G_OPTION_ARG_NONE, &option_version,
	  "Show version information and exit" },
	{ NULL },
};

static bool compare_interface(const char *interface, struct devices *devices)
{
	int i;

	if (!interface || !devices)
		return false;

	for (i = 0; devices->ignore && devices->ignore[i]; i++)
		if (!strcmp(interface, devices->ignore[i]))
			return false;

	if (!devices->interface)
		return true;

	for (i = 0; devices->interface[i]; i++)
		if (!strcmp(interface, devices->interface[i]))
			return true;

	return false;
}

static bool state_online(DBusMessageIter *iter)
{
	char *str;
	DBusMessageIter variant;

	if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_STRING)
		return false;

	dbus_message_iter_get_basic(iter, &str);
	if (strcmp(str, "State"))
		return false;

	dbus_message_iter_next(iter);

	if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_VARIANT)
		return false;

	dbus_message_iter_recurse(iter, &variant);

	if (dbus_message_iter_get_arg_type(&variant) != DBUS_TYPE_STRING)
		return false;

	dbus_message_iter_get_basic(&variant, &str);
	if (strcmp(str, "ready") && strcmp(str, "online"))
		return false;

	return true;
}

static bool service_properties_online(DBusMessageIter *array_entry,
				struct devices *devices)
{
	bool interface = !devices;
	bool state = false;
	DBusMessageIter dict, dict_entry, variant, eth_array, eth_dict,
		eth_variant;
	char *str;

	for (dbus_message_iter_recurse(array_entry, &dict);
	     dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY;
	     dbus_message_iter_next(&dict)) {

		dbus_message_iter_recurse(&dict, &dict_entry);
		if (dbus_message_iter_get_arg_type(&dict_entry)
				!= DBUS_TYPE_STRING)
			continue;

		if (state_online(&dict_entry)) {
			state = true;
			continue;
		}

		dbus_message_iter_recurse(&dict, &dict_entry);

		dbus_message_iter_get_basic(&dict_entry, &str);

		if (devices && !strcmp(str, "Ethernet")) {
			dbus_message_iter_next(&dict_entry);

			if (dbus_message_iter_get_arg_type(&dict_entry)
					!= DBUS_TYPE_VARIANT)
				break;

			dbus_message_iter_recurse(&dict_entry, &variant);
			if (dbus_message_iter_get_arg_type(&variant)
					!= DBUS_TYPE_ARRAY)
				break;

			for (dbus_message_iter_recurse(&variant, &eth_array);
			     dbus_message_iter_get_arg_type(&eth_array)
				     == DBUS_TYPE_DICT_ENTRY;
			     dbus_message_iter_next(&eth_array)) {

				dbus_message_iter_recurse(&eth_array, &eth_dict);

				if (dbus_message_iter_get_arg_type(&eth_dict)
						!= DBUS_TYPE_STRING)
					continue;

				dbus_message_iter_get_basic(&eth_dict, &str);
				if (!strcmp(str, "Interface")) {

					dbus_message_iter_next(&eth_dict);
					if (dbus_message_iter_get_arg_type(&eth_dict)
							!= DBUS_TYPE_VARIANT)
						break;

					dbus_message_iter_recurse(&eth_dict,
								&eth_variant);
					if (dbus_message_iter_get_arg_type(&eth_variant)
							!= DBUS_TYPE_STRING)
						break;

					dbus_message_iter_get_basic(&eth_variant,
								&str);
					interface = compare_interface(str,
								devices);

					break;
				}
			}
		}

		if (state && interface) {
			g_main_loop_quit(main_loop);
			return true;
		}
	}

	return false;
}

static void services_dict_online(DBusMessageIter *iter, struct devices *devices)
{
	DBusMessageIter array, array_entry;

	if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
		return;

	for (dbus_message_iter_recurse(iter, &array);
	     dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_STRUCT;
	     dbus_message_iter_next(&array)) {

		dbus_message_iter_recurse(&array, &array_entry);

		if (dbus_message_iter_get_arg_type(&array_entry) !=
				DBUS_TYPE_OBJECT_PATH)
			break;

		dbus_message_iter_next(&array_entry);

		if (dbus_message_iter_get_arg_type(&array_entry) !=
				DBUS_TYPE_ARRAY)
			continue;

		if (service_properties_online(&array_entry, devices))
			break;
	}
}

static void manager_get_services_return(DBusPendingCall *call,
					void *user_data)
{
	struct devices *devices = user_data;
	DBusMessage *reply;
	DBusMessageIter iter;

	reply = dbus_pending_call_steal_reply(call);
	if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
                goto fail;

        if (!dbus_message_iter_init(reply, &iter))
                goto fail;

	services_dict_online(&iter, devices);

fail:
	dbus_message_unref(reply);
	dbus_pending_call_unref(call);
}

static void manager_get_services(struct devices *devices)
{
	DBusMessage *message;
	DBusPendingCall *call;

	message = dbus_message_new_method_call(CONNMAN_SERVICE,
					CONNMAN_MANAGER_PATH,
					CONNMAN_MANAGER_INTERFACE,
					"GetServices");
	if (!message)
		return;

	if (!dbus_connection_send_with_reply(connection, message, &call, -1))
                goto fail;

        if (!call)
                goto fail;

	dbus_pending_call_set_notify(call, manager_get_services_return,
				devices, NULL);

fail:
        dbus_message_unref(message);
}

static void manager_properties_online(DBusMessageIter *iter,
				struct devices *devices)
{
	DBusMessageIter array, dict_entry;

	if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
		return;

	for (dbus_message_iter_recurse(iter, &array);
	     dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY;
	     dbus_message_iter_next(&array)) {

		dbus_message_iter_recurse(&array, &dict_entry);

		if (state_online(&dict_entry)) {
			if (devices)
				manager_get_services(devices);
			else
				g_main_loop_quit(main_loop);

			break;
		}
	}
}

static void manager_get_properties_return(DBusPendingCall *call, void *user_data)
{
	struct devices *devices = user_data;
	DBusMessage *reply;
	DBusMessageIter iter;

	reply = dbus_pending_call_steal_reply(call);
	if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
                goto fail;

        if (!dbus_message_iter_init(reply, &iter))
                goto fail;

	manager_properties_online(&iter, devices);

fail:
	dbus_message_unref(reply);
	dbus_pending_call_unref(call);
}

static void manager_get_properties(struct devices *devices)
{
	DBusMessage *message;
	DBusPendingCall *call;

	message = dbus_message_new_method_call(CONNMAN_SERVICE,
					CONNMAN_MANAGER_PATH,
					CONNMAN_MANAGER_INTERFACE,
					"GetProperties");
	if (!message)
		return;

	if (!dbus_connection_send_with_reply(connection, message, &call, -1))
                goto fail;

        if (!call)
                goto fail;

	dbus_pending_call_set_notify(call, manager_get_properties_return,
				devices, NULL);

fail:
        dbus_message_unref(message);
}

static DBusHandlerResult manager_property_changed(DBusConnection *connection,
                DBusMessage *message, void *user_data)
{
	struct devices *devices = user_data;
	DBusMessageIter iter;

	if (dbus_message_is_signal(message, CONNMAN_MANAGER_INTERFACE,
					"PropertyChanged")) {
		dbus_message_iter_init(message, &iter);

		if (state_online(&iter)) {
			if (devices)
				manager_get_services(devices);
			else
				g_main_loop_quit(main_loop);
		}
	}

	return DBUS_HANDLER_RESULT_HANDLED;
}

static gboolean timeout_triggered(gpointer user_data)
{
	exit_value = -ETIMEDOUT;
	g_main_loop_quit(main_loop);
	timeout = 0;

	return FALSE;
}

int main(int argc, char *argv[])
{
	const char *filter = "type='signal',interface='"
		CONNMAN_MANAGER_INTERFACE "'";
	int err = 0;
	GError *g_err = NULL;
	struct devices devices = { NULL, NULL };
	DBusError dbus_err;
	GOptionContext *context;

	context = g_option_context_new(NULL);
	g_option_context_add_main_entries(context, options, NULL);

	if (!g_option_context_parse(context, &argc, &argv, &g_err)) {
		if (g_err) {
			fprintf(stderr, "%s\n", g_err->message);
			g_error_free(g_err);
		} else
			fprintf(stderr, "An unknown error occurred\n");

		return EOPNOTSUPP;
	}

        g_option_context_free(context);

	if (option_interface) {
		devices.interface = g_strsplit(option_interface, ",", -1);
		g_free(option_interface);
	}

	if (option_ignore) {
		devices.ignore = g_strsplit(option_ignore, ",", -1);
		g_free(option_ignore);
	}

        if (option_version) {
		fprintf(stdout, "%s\n", VERSION);
		goto free;
	}

	dbus_error_init(&dbus_err);
	connection = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, &dbus_err);

	if (dbus_error_is_set(&dbus_err)) {
		fprintf(stderr, "Error: %s\n", dbus_err.message);

		err = -ENOPROTOOPT;
		goto fail;
	}

	main_loop = g_main_loop_new(NULL, FALSE);

	dbus_connection_add_filter(connection, manager_property_changed,
				&devices, NULL);

	dbus_bus_add_match(connection, filter, &dbus_err);

	if (dbus_error_is_set(&dbus_err)) {
		fprintf(stderr, "Error: %s\n", dbus_err.message);

		err = -ENOPROTOOPT;
		goto cleanup;
	}

	if (option_timeout)
		timeout = g_timeout_add_seconds(option_timeout,
						timeout_triggered, NULL);

	manager_get_properties(&devices);

	g_main_loop_run(main_loop);
	err = exit_value;

cleanup:
	dbus_bus_remove_match(connection, filter, NULL);
	dbus_connection_remove_filter(connection, manager_property_changed,
				&devices);

	dbus_connection_unref(connection);
	g_main_loop_unref(main_loop);

fail:
	dbus_error_free(&dbus_err);
free:
	g_strfreev(devices.interface);
	g_strfreev(devices.ignore);
	if (timeout)
		g_source_remove(timeout);

	return -err;
}