/* Userland modules emulation support
*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <signal.h>

#include <drivers/KernelExport.h>
#include <drivers/module.h>

#include <app/Application.h>
#include <app/Roster.h>
#include <kernel/OS.h>
#include <kernel/image.h>
#include <storage/StorageDefs.h>
#include <storage/FindDirectory.h>
#include <storage/Path.h>
#include <storage/Directory.h>

#define ASSERT(condition)	if (!(condition)) { debugger("Assertion failed!"); }

typedef enum {
  MODULE_LOADED = 0,
  MODULE_INITING,
  MODULE_READY,
  MODULE_UNINITING,
  MODULE_ERROR
} module_state;

typedef struct module {
	struct module * next;
	uint32 id;
	char * name;
	module_info * info;
	struct module_addon * addon;	// the module addon this module live in
									// if NULL, builtin module addon
	int32 ref_count;	// reference count of get_module() made on this module
	bool keep_loaded;
	module_state state;
} module;

typedef struct module_addon {
	struct module_addon * next;
	int32 ref_count;	// reference count of get_module() made using this addon
	bool keep_loaded;
	char * path;
	image_id addon_image;	// if -1, not loaded in memory currently
	module_info ** infos;	// valid only when addon_image != -1
} module_addon;

typedef struct module_list_cookie {
	char * prefix;
	char * search_paths;
	char * search_path;
	char * next_path_token;
	BList * dir_stack;
	module_addon * ma;	// current module addon looked up
	module_info ** mi;	// current module addon module info
} module_list_cookie;

#define LOCK_MODULES		acquire_sem(g_modules_lock)
#define UNLOCK_MODULES		release_sem(g_modules_lock)

// local prototypes
// ------------------

static module * search_module(const char * name);
static status_t init_module(module * m);
static status_t uninit_module(module * m);
static module * find_loaded_module_by_name(const char * name);
static module * find_loaded_module_by_id(uint32 id);

static module_addon * load_module_addon(const char * path);
static status_t unload_module_addon(module_addon * ma);

// globals
// ------------------

static sem_id g_modules_lock = -1;	// One lock for rule them all, etc...
static module * g_modules = NULL;
static module_addon * g_module_addons = NULL;
static int32 g_next_module_id = 1;


// Public routines
// ---------------

extern "C" {

_EXPORT status_t get_module(const char * name, module_info ** mi)
{
	status_t status;
	module * m;
	
	// printf("get_module(%s)\n", name);
	
	m = find_loaded_module_by_name(name);
	if (!m)
		m = search_module(name);
	
	if (!m)
		return B_NAME_NOT_FOUND;
	
	*mi = m->info;
	
	status = B_OK;

	if (m->addon) // built-in modules don't comes from addon...
		atomic_add(&m->addon->ref_count, 1);

	if (atomic_add(&m->ref_count, 1) == 0) {
		// first time we reference this module, so let's init it:
		status = init_module(m);
		if (status != B_OK) {
			printf("Failed to init module %s: %s.\n", m->name, strerror(status));
			unload_module_addon(m->addon);	// unload the module addon...
		};
	};
		
	return status;
}

_EXPORT status_t put_module(const char * name)
{
	module * m;

	// printf("put_module(%s)\n", name);
	
	m = find_loaded_module_by_name(name);
	if (!m)
		// Hum??? Sorry, this module name was never get_module()'d
		return B_NAME_NOT_FOUND;

	if (atomic_add(&m->ref_count, -1) <= 1)
		// this module is no more used...
		uninit_module(m);
	
	if (!m->addon)
		// built-in modules are module addon less...
		return B_OK;
	
	if (atomic_add(&m->addon->ref_count, -1) > 1)
		// Still other module(s) using this module addon
		return B_OK;
		
	// okay, this module addon is no more used
	// let's free up some memory
	return unload_module_addon(m->addon);
}


_EXPORT status_t get_next_loaded_module_name(uint32 *cookie, char *buf, size_t *bufsize)
{
	module * m;
	status_t status;
	
	if (buf == NULL && bufsize == NULL)
		return B_BAD_VALUE;

	LOCK_MODULES;

	if (*cookie == 0)
		// first call expected value
		m = g_modules;
	else {
		// find last loaded module returned, and seek to next one
		m = (module *) find_loaded_module_by_id((int) *cookie);
		if (m)
			m = m->next;
	};

	// find next loaded module
	while (m) {
		if (m->ref_count)
			break;
		m = m->next;
	};

	status = B_OK;
	if (m) {
		ASSERT(m->info);
		if (buf != NULL)
			strncpy(buf, m->info->name, *bufsize);
		else
			*bufsize = strlen(m->info->name + 1);
		*cookie = m->id;
	} else
		status = B_BAD_INDEX;

	UNLOCK_MODULES;

	return status;
}


_EXPORT void * open_module_list(const char *prefix)
{
	module_list_cookie * mlc;
	char * addon_path;
	
	if (prefix == NULL)
		return NULL;
		
	mlc = (module_list_cookie *) malloc(sizeof(*mlc));
	mlc->prefix = strdup(prefix);
	
	addon_path = getenv("ADDON_PATH");
	mlc->search_paths = (addon_path ? strdup(addon_path) : NULL);
	mlc->search_path = strtok_r(mlc->search_paths, ":", &mlc->next_path_token);
	mlc->dir_stack = new BList();
	
	mlc->ma = NULL;
	mlc->mi = NULL;

	return mlc;
}


_EXPORT status_t read_next_module_name(void *cookie, char *buf, size_t *bufsize)
{
	module_list_cookie * mlc = (module_list_cookie *) cookie;
	
	if (!bufsize)
		return B_BAD_VALUE;
	
	if (!mlc)
		return B_BAD_VALUE;
		
	/* Okay, take some time to understand how this function works!
	   Basicly, we iterate thru:
	   - each searchable add-ons path root
	   - each (sub-)directory under the current add-ons path root
	   - each module add-on file in the current (sub-)directory
	   - each module name published by current module add-on
	   
	   As the iteration involve sub-directory walks, we use recursive calls.
	   Sorry if this code sounds too complex...
	*/

	if (mlc->ma && mlc->mi) {
		// we have a module addon still loaded from a last call
		// so keep looking at his exported module names list
		while (*mlc->mi) {
			module_info * mi = *mlc->mi;
			mlc->mi++;
			if(strstr(mi->name, mlc->prefix)) {
				// We find a matching module name. At least. Yeah!!!
				if (buf) strncpy(buf, mi->name, *bufsize);
				*bufsize = strlen(mi->name);
				return B_OK;
			};
		};
		
		// We've iterate all module names of this module addon. Find another one...
		atomic_add(&mlc->ma->ref_count, -1);
		unload_module_addon(mlc->ma);
		mlc->ma = NULL;
		mlc->mi = NULL;
	};
		
	// Iterate all searchable add-ons paths
	while (mlc->search_path) {
		BDirectory * dir;
		BEntry entry;
		BPath path;
		status_t status;
			
		// Get current directory
		dir = (BDirectory *) mlc->dir_stack->LastItem();
		if (!dir) {
			// find add-ons root directory in this search path
			if (strncmp(mlc->search_path, "%A/", 3) == 0) {
				// resolve "%A/..." path
				app_info ai;
				
				be_app->GetAppInfo(&ai);
				entry.SetTo(&ai.ref);
				entry.GetPath(&path);
				path.GetParent(&path);
				path.Append(mlc->search_path + 3);
			} else {
				path.SetTo(mlc->search_path);
			};
			
			// We look *only* under prefix-matching sub-path 
			path.Append(mlc->prefix);

			// printf("Looking module(s) in %s/%s...\n", mlc->search_path, mlc->prefix);
			 
			dir = new BDirectory(path.Path());
			if (dir)
				mlc->dir_stack->AddItem(dir);
		};
		
		// Iterate current directory content
		if (dir) {  
			while (dir->GetNextEntry(&entry) == B_OK) {
				entry.GetPath(&path);
				// printf("  %s ?\n", path.Path());

				if (entry.IsDirectory()) {
					BDirectory * subdir;
					// push this directory on dir_stack
					subdir = new BDirectory(path.Path());
					if (!subdir)
						continue;
						
					mlc->dir_stack->AddItem(subdir);
					// recursivly search this sub-directory
					return read_next_module_name(cookie, buf, bufsize);
				};
				
				if (entry.IsFile() || entry.IsSymLink()) {
					mlc->ma = load_module_addon(path.Path());
		            if (!mlc->ma)
		            	// Oh-oh, not a loadable module addon!?
		            	// WTF it's doing there?!?
						continue;

					atomic_add(&mlc->ma->ref_count, 1);
					// call ourself to enter the module names list iteration at
					// function begining code...
					mlc->mi = mlc->ma->infos;
					return read_next_module_name(cookie, buf, bufsize);
				};
			};
			
			// We walk thru all this directory content, go back to parent
			status = mlc->dir_stack->RemoveItem(dir);
			delete dir;
		};
		
		if (!mlc->dir_stack->IsEmpty())
			continue;
			
		// We walk thru all this search path content, next now 
		mlc->search_path = strtok_r(NULL, ":", &mlc->next_path_token);
	};

	// Module(s) list search done, ending...
	return B_ERROR;		
}


_EXPORT status_t close_module_list(void *cookie)
{
	module_list_cookie * mlc = (module_list_cookie *) cookie;
	BDirectory * dir;

	ASSERT(mlc);
	ASSERT(mlc->prefix);

	if (mlc->ma) {
		atomic_add(&mlc->ma->ref_count, -1);
		unload_module_addon(mlc->ma);
	};

	while((dir = (BDirectory *) mlc->dir_stack->FirstItem())) {
		mlc->dir_stack->RemoveItem(dir);
		delete dir;
	};

	delete mlc->dir_stack;	
	
	free(mlc->search_paths);
	free(mlc->prefix);
	free(mlc);

	return B_ERROR;
}

// #pragma mark -
// Some KernelExport.h support from userland

_EXPORT void dprintf(const char *fmt, ...)
{
	va_list args;
	
	va_start(args, fmt);
	vprintf(fmt, args);
	va_end(args);
}


_EXPORT void kprintf(const char *fmt, ...)
{
	va_list args;
	
	va_start(args, fmt);
	vprintf(fmt, args);
	va_end(args);
}


_EXPORT status_t load_driver_symbols(const char *driver_name)
{
	// Userland debugger will extract symbols itself...
	return B_OK;
}


_EXPORT thread_id spawn_kernel_thread(thread_entry func, const char *name, long priority, void *arg)
{
	return spawn_thread(func, name, priority, arg);
}



_EXPORT int send_signal_etc(pid_t thid, uint sig, uint32 flags)
{
	return send_signal(thid, sig);
}	


}  // extern "C"


// #pragma mark -
// Private routines

static module_addon * load_module_addon(const char * path)
{
	module_addon * ma;
	image_id addon_id;
	module_info ** mi;
	status_t status;

	ASSERT(path);

	addon_id = load_add_on(path);
	if (addon_id < 0) {
		printf("Failed to load %s addon: %s.\n", path, strerror(addon_id));
		return NULL;
	};
	
	// printf("Addon %s loaded.\n", path);
		
	ma = NULL;
		
	status = get_image_symbol(addon_id, "modules", B_SYMBOL_TYPE_DATA, (void **) &mi);
	if (status != B_OK) {
		//  No "modules" symbol found in this addon
		printf("Symbol \"modules\" not found in %s addon: not a module addon!\n", path);
		goto error;
	};

	ma = (module_addon *) malloc(sizeof(*ma));
	if (!ma)
		// Gasp: not enough memory!
		goto error;
	
	LOCK_MODULES;

	ma->ref_count = 0;
	ma->keep_loaded = false;
	ma->path = strdup(path);
	ma->addon_image = addon_id;
	ma->infos = mi;

   	while(*mi)  {
		module * m;

		m = (module *) malloc(sizeof(*m));
		if (!m)
			// Gasp, again: not enough memory!
			goto error;
		
		m->ref_count = 0;
		m->id = atomic_add(&g_next_module_id, 1);
		m->info = (*mi);
		m->name = strdup(m->info->name);
		m->addon = ma;
		m->keep_loaded = (m->info->flags & B_KEEP_LOADED) ? true : false;
		            			
   		m->state = MODULE_LOADED;
		            			
		m->next = g_modules;
		g_modules = m;

   		mi++;
	};

	// add this module addon to the list
	ma->next = g_module_addons;
	g_module_addons = ma;

	UNLOCK_MODULES;
   			
	return ma;

error:
	printf("Error while load_module_addon(%s)\n", path);

	if (ma) {
		// remove any appended modules by this module addon until we got error... 
		module * prev;
		module * m;
		
		prev = NULL;
		m = g_modules;
		while (m) {
			if (m->addon == ma) {
				module * tmp = m;
				
				m = tmp->next;
				
				if (prev)
					prev->next = tmp->next;
				else
					g_modules = tmp->next;
					
				if (tmp->name)
					free(tmp->name);
				free(tmp);
				continue;
			};
			
			prev = m;
			m = m->next;
		};


		UNLOCK_MODULES;
	
		if (ma->path)
			free(ma->path);	
		free(ma);
	};

	unload_add_on(addon_id);
	// printf("Addon %s unloaded.\n", path);
	return NULL;
}

static status_t unload_module_addon(module_addon * ma)
{
	module * m;
	module * prev;
	status_t status;
	
	if (!ma)
		// built-in modules are addon-less, so nothing to do...
		return B_OK;

	if (ma->keep_loaded) {
		printf("B_KEEP_LOADED flag set for %s module addon. Will be *never* unloaded!\n",
			ma->path); 
		return B_OK;
	};

	if (ma->ref_count)
		// still someone needing this module addon, it seems?
		return B_OK;

	if (ma->addon_image < 0)
		// built-in addon, it seems...
		return B_OK;

	status = unload_add_on(ma->addon_image);
	if (status != B_OK) {
		printf("Failed to unload %s addon: %s.\n", ma->path, strerror(status));
		return status;
	};
	// printf("Addon %s unloaded.\n", ma->path);
		
	LOCK_MODULES;

	// remove the modules coming from this module addon from g_modules list
	prev = NULL;
	m = g_modules;
	while (m) {
		if (m->addon == ma) {
			module * tmp = m;
				
			m = tmp->next;
				
			if (prev)
				prev->next = tmp->next;
			else
				g_modules = tmp->next;
					
			if (tmp->name)
				free(tmp->name);
			free(tmp);
			continue;
		};
			
		prev = m;
		m = m->next;
	};

	// remove the module addon from g_module_addons list:
	if (g_module_addons == ma)
		g_module_addons = ma->next;
	else {
		module_addon * tmp;
		tmp = g_module_addons;
		while (tmp && tmp->next != ma)
			tmp = tmp->next;
			
		ASSERT(tmp);
		tmp->next = ma->next;
	};

	if (ma->path)
		free(ma->path);
	free(ma);
	
	UNLOCK_MODULES;
	
	return B_OK;
}


static module * search_module(const char * name)
{
	BPath path;
	BPath addons_path;
	BEntry entry;
	module * found_module;
	char * search_paths;
	char * search_path;
	char * next_path_token; 

	// printf("search_module(%s):\n", name);

	search_paths = getenv("ADDON_PATH");
	if (!search_paths)
		// Nowhere to search addons!!!
		return NULL;
		
	search_paths = strdup(search_paths);
	search_path = strtok_r(search_paths, ":", &next_path_token);
	
	found_module = NULL;
	while (search_path && found_module == NULL) {
		if (strncmp(search_path, "%A/", 3) == 0) {
			// compute "%A/..." path
			app_info ai;
			
			be_app->GetAppInfo(&ai);
			entry.SetTo(&ai.ref);
			entry.GetPath(&addons_path);
			addons_path.GetParent(&addons_path);
			addons_path.Append(search_path + 3);
		} else {
			addons_path.SetTo(search_path);
		};
		
		// printf("Looking into %s\n", search_path);

		path.SetTo(addons_path.Path());
		path.Append(name);
		
		while(path != addons_path) {
			// printf("  %s ?\n", path.Path());
			entry.SetTo(path.Path());
			if (entry.IsFile() || entry.IsSymLink()) {
				module_addon * ma;
			
				// try to load the module addon	
				ma = load_module_addon(path.Path());
	            if (ma) {
					found_module = find_loaded_module_by_name(name);
					if (found_module)
						break;

					unload_module_addon(ma);
				};	// if (ma)
			};	// if (entry.IsFile() || entry.IsSymLink())

			// okay, remove the current path leaf and try again...
			path.GetParent(&path);
		};
		
		search_path = strtok_r(NULL, ":", &next_path_token);
	};

	free(search_paths);

/*
	if (found_module)
		printf("  Found it in %s addon module!\n",
				found_module->addon ? found_module->addon->path : "BUILTIN");
*/

	return found_module;
}


static status_t init_module(module * m)
{
	status_t status;
	
	ASSERT(m);
	
	switch (m->state) {
	case MODULE_LOADED:
		m->state = MODULE_INITING;
		ASSERT(m->info);
		// printf("Initing module %s... ", m->name);
		status = m->info->std_ops(B_MODULE_INIT);
		// printf("done (%s).\n", strerror(status));
		m->state = (status == B_OK) ? MODULE_READY : MODULE_LOADED;
		
		if (m->state == MODULE_READY && m->keep_loaded && m->addon) {
  			// one module (at least) was inited and request to never being
			// unload from memory, so keep the corresponding addon loaded
   			// printf("module %s set B_KEEP_LOADED flag:\nmodule addon %s will never be unloaded!\n",
			//	m->name, m->addon->path);
   			m->addon->keep_loaded = true;
   		};
		break;
		
	case MODULE_READY:
		status = B_OK;
		break;
		
	case MODULE_INITING: 	// circular reference!!!
	case MODULE_UNINITING:	// initing a module currently unloading...
	case MODULE_ERROR: 		// module failed to unload previously...
	default:				// Unknown module state!!!
		status = B_ERROR;
		break;
	};
	
	return status;
}


static status_t uninit_module(module * m)
{
	status_t status;
	
	ASSERT(m);
	
	switch (m->state) {
	case MODULE_READY:		
		m->state = MODULE_UNINITING;
		ASSERT(m->info);
		// printf("Uniniting module %s... ", m->name);
		status = m->info->std_ops(B_MODULE_UNINIT);
		// printf("done (%s).\n", strerror(status));
		m->state = (status == B_OK) ? MODULE_LOADED : MODULE_ERROR;
		break;
		
	case MODULE_LOADED:
		// No need to uninit it, all is fine so.
		status = B_OK;
		break;
		
	case MODULE_INITING:	// uniniting while initializing
	case MODULE_UNINITING:	// uniniting already pending
	case MODULE_ERROR: 		// module failed previously...
	default:				// Unknown module state!!!
		status = B_ERROR;
		break;
	};
	
	return status;
}


static module * find_loaded_module_by_name(const char * name)
{
	module * m;
	
	LOCK_MODULES;
	
	m = g_modules;
	while (m) {
		if (strcmp(name, m->name) == 0)
			break;
		m = m->next;
	};
	
	UNLOCK_MODULES;
	return m;
}


static module * find_loaded_module_by_id(uint32 id)
{
	module * m;
	
	LOCK_MODULES;
	
	m = g_modules;
	while (m) {
		if (m->id == id)
			break;
		m = m->next;
	};
	
	UNLOCK_MODULES;
	return m;
}

#if 0
// #pragma mark -

#define NET_CORE_MODULE_NAME 		"network/core/v1"
#define NET_ETHERNET_MODULE_NAME 	"network/interfaces/ethernet"
#define NET_IPV4_MODULE_NAME 		"network/protocols/ipv4/v1"

#define MODULE_LIST_PREFIX	"network"

int main(int argc, char **argv)
{
	module_info * core;
	module_info * ethernet;
	module_info * ipv4;
	char module_name[256];
	uint32 cookie;
	size_t sz;
	void * ml_cookie;
	
	new BApplication("application/x-vnd-OBOS-net_server");
	
	printf("open_module_list(%s):\n", MODULE_LIST_PREFIX);
	ml_cookie = open_module_list(MODULE_LIST_PREFIX);
	sz = sizeof(module_name);
	while(read_next_module_name(ml_cookie, module_name, &sz) == B_OK) {
		if (strlen(module_name))
			printf("  %s\n", module_name);
		sz = sizeof(module_name);
	};
	close_module_list(ml_cookie);
	printf("close_module_list()\n");
	// return 0;
	
	core = NULL;
	get_module(NET_CORE_MODULE_NAME, (module_info **) &core);
	
	ethernet = NULL;
	get_module(NET_ETHERNET_MODULE_NAME, (module_info **) &ethernet);
	
	ipv4 = NULL;
	get_module(NET_IPV4_MODULE_NAME, (module_info **) &ipv4);
	
	printf("get_next_loaded_module_name() test:\n");
	cookie = 0;
	sz = sizeof(module_name);
	while (get_next_loaded_module_name(&cookie, module_name, &sz) == B_OK)
		printf("%ld: %s\n", cookie, module_name);

	if (ipv4)
		put_module(NET_IPV4_MODULE_NAME);

	if (ethernet)
		put_module(NET_ETHERNET_MODULE_NAME);

	if (core)
		put_module(NET_CORE_MODULE_NAME);

	printf("get_next_loaded_module_name() test:\n");
	cookie = 0;
	sz = sizeof(module_name);
	while (get_next_loaded_module_name(&cookie, module_name, &sz) == B_OK)
		printf("%ld: %s\n", cookie, module_name);

	delete be_app;
	return 0;
}
#endif