#include "module_manager_interna.h"

#include "stellar/utils.h"
#include <dlfcn.h>
#include <stdbool.h>
#include <assert.h>
#include <string.h>

#include "toml/toml.h"

/*******************************************
 * module manager  API *
 *******************************************/

struct module_manager *module_manager_new(struct module_hooks mod_hooks[], size_t n_mod, int max_thread_num, const char *toml_path, struct mq_schema *mq_schema, struct logger *logger)
{
	struct module_manager *mod_mgr = CALLOC(struct module_manager, 1);
	mod_mgr->config.max_thread_num=max_thread_num;
	mod_mgr->config.mq_schema=mq_schema;
	mod_mgr->config.logger=logger;
	if(toml_path)mod_mgr->config.toml_path=strdup(toml_path);

	if(mod_hooks==NULL || n_mod==0)return mod_mgr;

	mod_mgr->descriptors = CALLOC(struct module_descriptor, n_mod);
	mod_mgr->n_descriptor = n_mod;

	for (size_t i = 0; i < n_mod; i++) 
	{
		mod_mgr->descriptors[i].hooks = mod_hooks[i];
        if (mod_hooks[i].on_instance_init_cb)
        {
            mod_mgr->descriptors[i].mod = mod_hooks[i].on_instance_init_cb(mod_mgr);
            if (module_manager_get_module(mod_mgr, mod_mgr->descriptors[i].mod->name) == NULL)
            {
                mod_mgr->descriptors[i].initialized = true;
            }
            else
            {
                fprintf(stderr, "Module %s already exists\n", mod_mgr->descriptors[i].mod->name);
                if (mod_hooks[i].on_instance_exit_cb)
                    mod_hooks[i].on_instance_exit_cb(mod_mgr, mod_mgr->descriptors[i].mod);
            }
        }
    }
	return mod_mgr;
}

struct module_manager *module_manager_new_with_toml(const char *toml_path, int max_thread_num, struct mq_schema *mq_schema, struct logger *logger)
{
	
	FILE *fp=fopen(toml_path, "r");
	if(!fp)return module_manager_new(NULL, 0, max_thread_num, toml_path, mq_schema, logger);

	toml_table_t *conf = toml_parse_file(fp, NULL, 0);
	fclose(fp);

	if(conf==NULL)return module_manager_new(NULL, 0, max_thread_num, toml_path, mq_schema, logger);

    toml_array_t* mod_array = toml_array_in(conf, "module");
	if(mod_array==NULL)
	{
		toml_free(conf);
		return module_manager_new(NULL, 0, max_thread_num, toml_path, mq_schema, logger);
	}

    int mod_num = toml_array_nelem(mod_array);

	struct module_hooks mod_hooks[mod_num];
	memset(mod_hooks, 0, sizeof(mod_hooks));

    for (int i = 0; i < mod_num; i++) 
	{
        toml_table_t* toml_mod = toml_table_at(mod_array, i);

        const char *path_raw = toml_raw_in(toml_mod, "path");
        const char *init_func_name_raw = toml_raw_in(toml_mod, "init");
        const char *exit_func_name_raw = toml_raw_in(toml_mod, "exit");
		const char *thread_init_func_name_raw = toml_raw_in(toml_mod, "thread_init");
		const char *thread_exit_func_name_raw = toml_raw_in(toml_mod, "thread_exit");

        char *path = NULL;
        char *instance_init_cb_name = NULL, *instance_exit_cb_name = NULL, *thread_init_cb_name = NULL,
             *thread_exit_cb_name = NULL;

        toml_rtos(path_raw, &path);
		toml_rtos(init_func_name_raw, &instance_init_cb_name);
		toml_rtos(exit_func_name_raw, &instance_exit_cb_name);
		toml_rtos(thread_init_func_name_raw, &thread_init_cb_name);
		toml_rtos(thread_exit_func_name_raw, &thread_exit_cb_name);

        void* handle = dlopen(path, RTLD_NOW|RTLD_LAZY|RTLD_GLOBAL);
        if (!handle) {
            fprintf(stderr, "Error loading module %s: %s\n", path, dlerror());
            break;
        }
        if (instance_init_cb_name)
        {
            mod_hooks[i].on_instance_init_cb =
                (module_on_instance_init_func *)dlsym(handle, instance_init_cb_name);
			//TODO: logger error

			FREE(instance_init_cb_name);
        }
        if (instance_exit_cb_name)
        {
            mod_hooks[i].on_instance_exit_cb =
                (module_on_instance_exit_func *)dlsym(handle, instance_exit_cb_name);
			FREE(instance_exit_cb_name);
        }

        if (thread_init_cb_name)
        {
            mod_hooks[i].on_thread_init_cb =
                (module_on_thread_init_func *)dlsym(handle, thread_init_cb_name);
			FREE(thread_init_cb_name);
        }

        if (thread_exit_cb_name)
        {
            mod_hooks[i].on_thread_exit_cb =
                (module_on_thread_exit_func *)dlsym(handle, thread_exit_cb_name);
			FREE(thread_exit_cb_name);	
        }
    }

	toml_free(conf);
	return module_manager_new(mod_hooks, mod_num, max_thread_num, toml_path, mq_schema, logger);
}


void module_manager_free(struct module_manager *mod_mgr)
{
	if(mod_mgr==NULL)return;
	if(mod_mgr->config.toml_path)FREE(mod_mgr->config.toml_path);
    if (mod_mgr->descriptors)
    {
        for (int i = 0; i < mod_mgr->n_descriptor; i++)
        {
            if (mod_mgr->descriptors[i].hooks.on_instance_exit_cb != NULL &&
                mod_mgr->descriptors[i].initialized)
            {
                mod_mgr->descriptors[i].hooks.on_instance_exit_cb(mod_mgr, mod_mgr->descriptors[i].mod);
            }
        }
		FREE(mod_mgr->descriptors);
    }
    FREE(mod_mgr);
	return;
}

int module_manager_get_max_thread_num(struct module_manager*mod_mgr)
{
	if(mod_mgr==NULL)return -1;
	return mod_mgr->config.max_thread_num;
}

struct mq_schema *module_manager_get_mq_schema(struct module_manager *mod_mgr)
{
	if(mod_mgr==NULL)return NULL;
	return mod_mgr->config.mq_schema;
}

struct logger *module_manager_get_logger(struct module_manager *mod_mgr)
{
	if(mod_mgr==NULL)return NULL;
	return mod_mgr->config.logger;
}

const char *module_manager_get_toml_path(struct module_manager *mod_mgr)
{
	if(mod_mgr==NULL)return NULL;
	return mod_mgr->config.toml_path;
}

__thread int local_thread_id=-1;
__thread struct mq_runtime *local_mq_rt=NULL;

int module_manager_get_thread_id(struct module_manager* mod_mgr __unused)
{
	return local_thread_id;
}

struct mq_runtime *module_manager_get_mq_runtime(struct module_manager *mod_mgr __unused)
{
	return local_mq_rt;
}

void module_manager_register_thread(struct module_manager* mod_mgr, int thread_id, struct mq_runtime *mq_rt)
{
	local_thread_id=thread_id;
	local_mq_rt=mq_rt;

	for(int i=0; i<mod_mgr->n_descriptor; i++)
	{
		if(mod_mgr->descriptors[i].mod == NULL)break;
		if(mod_mgr->descriptors[i].hooks.on_thread_init_cb && mod_mgr->descriptors[i].initialized)
		{
			mod_mgr->descriptors[i].hooks.on_thread_init_cb(mod_mgr, thread_id, mod_mgr->descriptors[i].mod);
		}
	}
	return;
}

void module_manager_unregister_thread(struct module_manager *mod_mgr, int thread_id)
{
	assert(local_thread_id==thread_id);
	for(int i=0; i<mod_mgr->n_descriptor; i++)
	{
		if(mod_mgr->descriptors[i].mod == NULL)break;
		if(mod_mgr->descriptors[i].hooks.on_thread_exit_cb && mod_mgr->descriptors[i].initialized)
		{
			mod_mgr->descriptors[i].hooks.on_thread_exit_cb(mod_mgr, thread_id, mod_mgr->descriptors[i].mod);
		}
	}
	local_thread_id=-1;
	local_mq_rt=NULL;
	return;
}

struct module *module_manager_get_module(struct module_manager *mod_mgr, const char *module_name)
{
	if(mod_mgr==NULL || module_name == NULL)return NULL;
	if (mod_mgr->descriptors)
	{
		for(int i=0; i<mod_mgr->n_descriptor; i++)
		{
			if(mod_mgr->descriptors[i].mod == NULL)break;
			if(strcmp(mod_mgr->descriptors[i].mod->name, module_name)==0 && mod_mgr->descriptors[i].initialized)
			{
				return mod_mgr->descriptors[i].mod;
			}
		}
	}
	return NULL;
} 

/*******************************************
 * stellar module API *
 *******************************************/


struct module *module_new(const char *name, void *ctx)
{
	struct module *mod = CALLOC(struct module, 1);
	memcpy(mod->name, name, MIN(NAME_MAX, strlen(name)));
	mod->ctx=ctx;
	return mod;
}

void module_free(struct module *mod)
{
	if(mod==NULL)return;
	FREE(mod);
	return;
}

void * module_get_ctx(struct module *mod)
{
	if(mod==NULL)return NULL;
	return mod->ctx;
}

void module_set_ctx(struct module *mod, void *ctx)
{
	if(mod==NULL)return;
	mod->ctx=ctx;
	return;
}

const char *module_get_name(struct module* mod)
{
	if(mod==NULL)return NULL;
	return mod->name;
}

void module_set_name(struct module* mod, const char *name)
{
	if(mod==NULL)return;
	memcpy(mod->name, name, MIN(NAME_MAX, strlen(name)));
	return;
}

/*******************************************
 * polling API *
 *******************************************/

 #define TOPIC_POLLING "polling"

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-function-type"
static void on_polling_dispatch(int topic_id __unused, 
									 void *msg __unused,  
									on_msg_cb_func* on_msg_cb, 
									 void *on_msg_cb_arg, 
									 void *dispatch_arg)
{
	struct module_manager *mod_mgr=(struct module_manager *)dispatch_arg;
	module_on_polling_func *polling = (module_on_polling_func *)on_msg_cb;
	polling(mod_mgr, on_msg_cb_arg);
}

int module_manager_polling_subscribe(struct module_manager	*mod_mgr,  module_on_polling_func on_polling, void *polling_arg)
{
	if(mod_mgr == NULL)return -1;
	mod_mgr->topic_polling_id=mq_schema_get_topic_id(module_manager_get_mq_schema(mod_mgr), TOPIC_POLLING);
	if(mod_mgr->topic_polling_id<0)
	{
		mod_mgr->topic_polling_id=mq_schema_create_topic(mod_mgr->config.mq_schema, TOPIC_POLLING, on_polling_dispatch, mod_mgr, NULL, NULL);
	}
	return mq_schema_subscribe(mod_mgr->config.mq_schema, mod_mgr->topic_polling_id, (on_msg_cb_func *)on_polling, polling_arg);
}

#pragma GCC diagnostic pop 

void module_manager_polling_active(struct module_manager *mod_mgr)
{
	if(mod_mgr == NULL)return;
	mq_runtime_publish_message(local_mq_rt, mod_mgr->topic_polling_id, NULL);
}


void module_manager_polling_dispatch(struct module_manager *mod_mgr)
{
	if(mod_mgr==NULL)return;
	module_manager_polling_active(mod_mgr);
	mq_runtime_dispatch(local_mq_rt);
	return;
}