#include <dbus/dbus.h>
#include <dbus/dbus-glib.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

bool init(DBusError **error, DBusConnection **connection) {
	*error = malloc(sizeof(struct DBusError));
	if(*error == NULL)
		return 1;

	//initialise the errors
	dbus_error_init(*error);

	//connect to the bus
	*connection = dbus_bus_get(DBUS_BUS_SESSION, *error);
	
	if(*connection == NULL)
		return 1;

	if(dbus_error_is_set(*error)){
		fprintf(stderr, "Connection Error (%s)\n", (*error)->message);
		dbus_error_free(*error);
		return 1;
	}

	//request a name on the bus
	int result = dbus_bus_request_name(*connection, "hackerman.notifier.app", DBUS_NAME_FLAG_REPLACE_EXISTING, *error);

	if(dbus_error_is_set(*error)) {
		fprintf(stderr, "Name Error (%s)\n", (*error)->message);
		dbus_error_free(*error);
		return 1;
	}

	if(DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != result)
		return 1;

	return 0;
}

void add_arg_basic(DBusMessageIter * const args,const int type, void * const data){
	int status_code = dbus_message_iter_append_basic(args, type, data);
	if(!status_code){
		fprintf(stderr, "Error while appending args\n");
		exit(1);
	}
}

bool add_arg_fixed(DBusMessageIter * const args, DBusMessageIter ** const subargs) {
	*subargs = malloc(sizeof(struct DBusMessageIter));
	if(*subargs == NULL)
		return 1;

	dbus_message_iter_open_container(args, DBUS_TYPE_ARRAY, "s", *subargs);
	//static const char *str = " ";
	//dbus_message_iter_append_basic(subargs, DBUS_TYPE_STRING, &str);
	int status_code = dbus_message_iter_close_container(args, *subargs);
	if(!status_code){
		fprintf(stderr, "Error while appending args\n");
		//exit(1);
	}

	return 0;
}
bool add_arg_dict(DBusMessageIter *args, DBusMessageIter ** const subargs) {
	*subargs = malloc(sizeof(struct DBusMessageIter));

	if(*subargs == NULL)
		return 1;

	dbus_message_iter_open_container(args, DBUS_TYPE_DICT_ENTRY, NULL, *subargs);
	
	int status_code = dbus_message_iter_close_container(args, *subargs);
	if(!status_code){
		fprintf(stderr, "Error while appending args\n");
		//exit(1);
	}

	return 0;
}


bool send_message(DBusError * const error, DBusConnection * const connection) {
	DBusMessageIter args;
	DBusPendingCall *pending;

	DBusMessage *message = dbus_message_new_method_call(
		"org.freedesktop.Notifications",
		"/org/freedesktop/Notifications/",
		"org.freedesktop.Notifications",
		"Notify"
	);
	char * bus_id= dbus_bus_get_id(connection, error);
	printf("%s", bus_id);

	if(message == NULL) {
		fprintf(stderr, "Message Null\n");
		return 1;
	}
	
	//append arguments to iterator
	
	dbus_message_iter_init_append(message, &args);

	char *app_name = "App Name";
	char *app_icon = "App Icon";
	char *summary = "Summary";
	char *body = "Body";
	dbus_uint32_t replaces_id = 0;
	dbus_int32_t expire_timeout = 0;

	add_arg_basic(&args, DBUS_TYPE_STRING, &app_name);
	add_arg_basic(&args, DBUS_TYPE_UINT32, &replaces_id);
	add_arg_basic(&args, DBUS_TYPE_STRING, &app_icon);
	add_arg_basic(&args, DBUS_TYPE_STRING, &summary);
	add_arg_basic(&args, DBUS_TYPE_STRING, &body);
	
	DBusMessageIter *subargs1, *subargs2;
	add_arg_fixed(&args, &subargs1);
	add_arg_dict(&args, &subargs2);
	add_arg_basic(&args, DBUS_TYPE_INT32, &expire_timeout);
		
	if(!dbus_connection_send_with_reply(connection, message, &pending, -1))
		fprintf(stderr, "Message couldn't be sent\n");
	
	if(pending == NULL)
		fprintf(stderr, "Pending Call Null\n");

	dbus_connection_flush(connection);
	printf("Request Sent\n");

	dbus_message_unref(message);
	dbus_pending_call_block(pending);

	message = dbus_pending_call_steal_reply(pending);
	if(message == NULL)
		fprintf(stderr, "Null reply\n");
	
	dbus_pending_call_unref(pending);
	
	free(subargs1);
	free(subargs2);

	return 0;
}


int main(int argc, char **argv) {
	DBusError* error;
	DBusConnection *connection;
	
	if(init(&error, &connection)) {
		fprintf(stderr, "Init failed");
		return 1;
	}

	if(send_message(error, connection)) {
		fprintf(stderr, "Sending message failed");
		return 1;
	}
	
	free(error);
}