#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifndef __WIN32__
#include <dlfcn.h>
#endif
#include <assert.h>

#include "main.h"
#include "list.h"
#include "tux.h"
#include "shot.h"
#include "modules.h"
#include "arena.h"
#include "arenaFile.h"
#include "proto.h"
#include "shareFunction.h"

#ifndef PUBLIC_SERVER
#include "interface.h"
#include "image.h"
#include "layer.h"
#include "configFile.h"
#endif

static export_fce_t export_fce =
	{
#ifndef PUBLIC_SERVER
		.fce_addLayer = addLayer,
		.fce_getImage = getImage,
#endif
		.fce_loadDepModule = loadDepModule,
		.fce_addToShareFce = addToShareFce,
		.fce_getShareFce = getShareFce,

		.fce_getValue = getArenaValue,
		.fce_getNetTypeGame = getNetTypeGame,
		.fce_getTuxProportion = getTuxProportion,
		.fce_setTuxProportion = setTuxProportion,
		.fce_actionTux = actionTux,

		.fce_getMyTime = getMyTime,

		.fce_getCurrentArena = getCurrentArena,
		.fce_conflictSpace = conflictSpace,
		.fce_isFreeSpace = isFreeSpace,
		.fce_findFreeSpace = findFreeSpace,

		.fce_proto_send_module_server = proto_send_module_server,
#ifndef PUBLIC_SERVER
		.fce_proto_send_module_client = proto_send_module_client,
#endif

		.fce_destroyShot = destroyShot,
		.fce_boundBombBall = boundBombBall,
		.fce_transformOnlyLasser = transformOnlyLasser
	};

static list_t *listModule;

static void* getFce(module_t *p, char *s)
{
#ifndef __WIN32__

	void *ret;
	char *error;

	assert( p != NULL );
	assert( s != NULL );
	
	ret = dlsym(p->image, s);

	if( ( error = dlerror() ) != NULL)
	{
		fprintf (stderr, "error = %s\n", error);
		return NULL;
	}
#else
	FARPROC ret = GetProcAddress((HMODULE)p->image,(LPCSTR)s);
	if ( !ret )
		fprintf(stderr, "n_dllsymbol(%s) failed!\n", s);

	
#endif
	return (void *)ret;
}

static void* mapImage(char *name)
{
#ifndef __WIN32__
	void *image;
	image = dlopen (name, RTLD_LAZY);

	if( image == NULL )
	{
		fputs (dlerror(), stderr);
		return NULL;
	}
#else
	HINSTANCE image;
	image = LoadLibrary((LPCSTR) name);

	if (!image)
	{
		LPVOID msg;
		FormatMessage(
			FORMAT_MESSAGE_ALLOCATE_BUFFER |
			FORMAT_MESSAGE_FROM_SYSTEM |
			FORMAT_MESSAGE_IGNORE_INSERTS,
			NULL,
			GetLastError(),
			MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
			(LPTSTR) &msg,
			0,
			NULL
		);
		fputs(msg, stderr);
		free(msg);
		FreeLibrary(image);
		return NULL;
	}
	//FreeLibrary(image); //to tu nema bejt
#endif

	return image;
}

static void unmapImage(void *image)
{
#ifndef __WIN32__
	dlclose(image);
#else
	FreeLibrary(image);
#endif
}

static void setModulePath(char *name, char *path)
{
	sprintf(path, PATH_MODULES "%s" MODULE_TYPE_UNIX, name); // linux
#ifdef __WIN32__
	sprintf(path, PATH_MODULES "%s" MODULE_TYPE_WIN, name); // windows
#endif
#ifdef APPLE
	sprintf(path, PATH_MODULES "%s" MODULE_TYPE_APPLE, name); // apple
#endif
}

static module_t* newModule(char *name)
{
	char path[STR_PATH_SIZE];
	void *image;
	module_t *ret;

	assert( name != NULL );

	setModulePath(name, path);
	image = mapImage(path);

	if( image == NULL )
	{
		fprintf(stderr, "I dont map %s file  !\n", name);
		return NULL;
	}

	ret = malloc( sizeof(module_t) );

	ret->image = image;
	ret->name = strdup(name);

	ret->fce_init = getFce(ret, "init");
#ifndef PUBLIC_SERVER
	ret->fce_draw = getFce(ret, "draw");
#endif
	ret->fce_event = getFce(ret, "event");
	ret->fce_destroy = getFce(ret, "destroy");
	ret->fce_isConflict = getFce(ret, "isConflict");
	ret->fce_cmd = getFce(ret, "cmdArena");
	ret->fce_recvMsg = getFce(ret, "recvMsg");

	printf("load module: (%s)\n", name);

	if( ret->fce_init(&export_fce) != 0 )
	{
		fprintf(stderr, "init module failed !\n");
		unmapImage(image);
		free(ret->name);
		free(ret);

		return NULL;
	}

	return ret;
}

static int destroyModule(module_t *p)
{
	assert( p != NULL );

	p->fce_destroy();
	unmapImage(p->image);
	free(p->name);
	free(p);

	printf("destroy module..\n");

	return 0;
}

void initModule()
{
	listModule = newList();
	initShareFunction();
}

int isModuleLoaded(char *name)
{
	int i;

	for( i = 0 ; i < listModule->count ; i++ )
	{
		module_t *this;

		this = (module_t *)listModule->list[i];

		if( strcmp(this->name, name) == 0 )
		{
			return 1;
		}
	}

	return 0;
}

int loadModule(char *name)
{
	module_t *module;

	if( isModuleLoaded(name) )
	{
		fprintf(stderr, "dupicit loaded module %s !\n", name);
		return -1;
	}

	module = newModule(name);

	if( module == NULL )
	{
		fprintf(stderr, "load module %s failed !\n", name);
		return -1;
	}

	addList(listModule, module);

	return 0;
}

int loadDepModule(char *name)
{
	if( isModuleLoaded(name) )
	{
		return 0;
	}

	return loadModule(name);
}

void cmdModule(char *s)
{
	int i;

	for( i = 0 ; i < listModule->count ; i++ )
	{
		module_t *this;
		this = (module_t *)listModule->list[i];
		this->fce_cmd(s);
	}
}

#ifndef PUBLIC_SERVER

void drawModule(int x, int y, int w, int h)
{
	int i;

	for( i = 0 ; i < listModule->count ; i++ )
	{
		module_t *this;
		this = (module_t *)listModule->list[i];
		this->fce_draw(x, y, w, h);
	}
}

#endif

void eventModule()
{
	int i;

	for( i = 0 ; i < listModule->count ; i++ )
	{
		module_t *this;
		this = (module_t *)listModule->list[i];
		this->fce_event();
	}
}

int isConflictModule(int x, int y, int w, int h)
{
	int i;

	for( i = 0 ; i < listModule->count ; i++ )
	{
		module_t *this;
		this = (module_t *)listModule->list[i];

		if( this->fce_isConflict(x, y, w, h) == 1 )
		{
			return 1;
		}
	}

	return 0;
}

int recvMsgModule(char *msg)
{
	int i;

	for( i = 0 ; i < listModule->count ; i++ )
	{
		module_t *this;

		this = (module_t *)listModule->list[i];
		this->fce_recvMsg(msg);
	}

	return 0;
}

void quitModule()
{
	destroyListItem(listModule, destroyModule);
	quitShareFunction();
}