#pragma implementation
#include <stdio.h>
#include <string.h>
#include <translat.h>
#include "vregistry.h"
#include "vregistry.m"
#include <modregister.h>
#include <module_apis/vregistry_apidef.h>
#include <module_api.h>

MODULE_DEFINE_VERSION(vregistry);

/*
	Retrieve the list of available variable, with description
*/
static void vregistry_list (SSTRING_KEYS &tb)
{
	for (int i=0; i<master_registry.getnb(); i++){
		REGISTER_VARIABLES_OBJ *mod = master_registry.getitem(i);
		for (int j=0; j<mod->getnb(); j++){
			REGISTER_VARIABLE *var = mod->getitem(j);
			SSTRING tmp,suffix;
			if (var->is_record()){
				SSTRING listvar;
				if (var->getlistvar(listvar)==-1){
					suffix.setfrom (".*");
				}else{
					suffix.setfromf (".[%s]",listvar.get());
				}
			}
			tmp.setfromf ("%s.%s%s",mod->get_module_id()
				,var->get_varname()
				,suffix.get());
			tb.add (tmp.get(),var->get_prompt());
		}
	}
	tb.sort();
}

static int vregistry_getvars(
	VREGISTRY_API *api,
	SSTRINGS &vars)
{
	SSTRING_KEYS tb;
	vregistry_list (tb);
	int n = tb.getnb();
	for (int i=0; i<n; i++){
		SSTRING_KEY *k = tb.getitem(i);
		vars.add (new SSTRING(k->get()));
	}
	return n;
}

static int vregistry_getval(
	VREGISTRY_API *api,
	const char *var,
	SSTRING &val)
{
	int ret = -1;
	const char *s = master_registry.get(var);
	if (s != NULL){
		ret = 0;
		val.setfrom (s);
	}
	return ret;
}

static int vregistry_setval(
	VREGISTRY_API *api,
	const char *var,
	const char *val)
{
	return master_registry.set(var,val);
}


static void vregistry_api_release (void *_api)
{
	VREGISTRY_API *api = (VREGISTRY_API*)_api;
	delete api;
	master_registry.end_session();
}

static void *vregistry_api_get()
{
	VREGISTRY_API *api = new VREGISTRY_API;
	api->getvars = vregistry_getvars;
	api->getval = vregistry_getval;
	api->setval = vregistry_setval;
	master_registry.start_session();
	return api;
}

class VREGISTRY_API_SERIAL: public MODULE_API_SERIAL{
	VREGISTRY_API *api;
	/*~PROTOBEG~ VREGISTRY_API_SERIAL */
public:
	VREGISTRY_API_SERIAL (void);
private:
	int exec (const char *func,
		 int nbparm,
		 const char *parms[],
		 SSTRINGS&res);
public:
	~VREGISTRY_API_SERIAL (void);
	/*~PROTOEND~ VREGISTRY_API_SERIAL */
};

PUBLIC VREGISTRY_API_SERIAL::VREGISTRY_API_SERIAL()
{
	api = (VREGISTRY_API*)vregistry_api_get();
}

PUBLIC VREGISTRY_API_SERIAL::~VREGISTRY_API_SERIAL()
{
	delete api;
}

PRIVATE int VREGISTRY_API_SERIAL::exec (
	const char *func,
	int nbparm,
	const char *parms[],
	SSTRINGS &tbres)
{
	int ret = -2;
	if (strcmp(func,"getvars")==0 && nbparm==0){
		ret = api->getvars (api,tbres);
	}else if (strcmp(func,"getval")==0 && nbparm==1){
		SSTRING *val = new SSTRING;
		ret = api->getval (api,parms[0],*val);
		if (ret == -1){
			delete val;
		}else{
			tbres.add (val);
		}
	}else if (strcmp(func,"setval")==0 && nbparm==2){
		ret = api->setval (api,parms[0],parms[1]);
	}
	return ret;
}


static MODULE_API_SERIAL *vregistry_serial()
{
	return new VREGISTRY_API_SERIAL;
}

PUBLIC MODULE_vregistry::MODULE_vregistry()
	: LINUXCONF_MODULE("vregistry")
{
	linuxconf_loadmsg ("vregistry",PACKAGE_REV);
	module_register_api ("vregistry",1,vregistry_api_get
		,vregistry_api_release);
	module_register_api_serial ("vregistry",1,vregistry_serial);
}



PUBLIC int MODULE_vregistry::dohtml (const char *key)
{
	int ret = LNCF_NOT_APPLICABLE;
	if (strcmp(key,"vregistry")==0){
		ret = 0;
	}
	return ret;
}


static void usage()
{
	xconf_error (MSG_U(T_USAGE
		,"Module vregistry\n"
		 "linuxconf --modulemain vregistry [ specific options ]\n"
		 "\n"
		 "    vregistry --get variable variable\n"
		 "    vregistry --getvalue variable variable\n"
		 "    vregistry --list\n"
		 "    vregistry --rundialog variable\n"
		 "    vregistry --set variable value [ variable value ...]\n"
		 "    vregistry --server\n"
		 "\n")
		);
}

PUBLIC void MODULE_vregistry::usage (SSTRINGS &tb)
{
	tb.add (new SSTRING (MSG_R(T_USAGE)));
}

static void vregistry_list ()
{
	master_registry.start_session();
	SSTRING_KEYS tb;
	vregistry_list (tb);
	for (int i=0; i<tb.getnb(); i++){
		SSTRING_KEY *s = tb.getitem(i);
		printf ("%s\t\"%s\"\n",s->get(),s->getobjval());
	}
	master_registry.end_session();
}
	

PUBLIC int MODULE_vregistry::execmain (int argc , char *argv[], bool)
{
	int ret = LNCF_NOT_APPLICABLE;
	const char *pt = strrchr(argv[0],'/');
	if (pt != NULL){
		pt++;
	}else{
		pt = argv[0];
	}
	if (strcmp(pt,"vregistry")==0){
		ret = -1;
		if (perm_rootaccess(MSG_U(P_REGISTRY,"to use the virtual registry"))){
			const char *arg = argv[1];
			error_setmode (true);
			if (argc < 2){
				::usage();
			}else if (strcmp(arg,"--list")==0){
				if (argc != 2){
					::usage();
				}else{
					vregistry_list();
					ret = 0;
				}
			}else if (strcmp(arg,"--get")==0 || strcmp(arg,"--getvalue")==0){
				master_registry.start_session();
				for (int i=2; i<argc; i++){
					const char *var = argv[i];
					SSTRINGS tb;
					int nb = master_registry.getlist(var,tb);
					if (nb >= 0){
						tb.sort();
						if (strcmp(arg,"--get")==0){
							printf ("%s=",var);
							for (int i=0; i<nb; i++){
								printf (i==0 ? "%s" : " %s"
									,tb.getitem(i)->get());
							}
							printf ("\n");
						}else{
							for (int i=0; i<nb; i++){
								printf ("%s\n"
									,tb.getitem(i)->get());
							}
						}
					}else{
						const char *val = master_registry.get(var);
						if (val == NULL){
							val = "";
							fprintf (stderr,MSG_U(E_NOVAR
								,"Variable %s does not exist\n"),var);
						}
						if (strcmp(arg,"--get")==0){
							printf ("%s=%s\n",var,val);
						}else{
							printf ("%s\n",val);
						}
					}
				}
				master_registry.end_session();
			}else if (strcmp(arg,"--set")==0){
				if ((argc & 1) != 0){
					fprintf (stderr,MSG_U(E_PAIRSNEEDED
						,"You must supplied variable/values pairs\n"));
				}else{
					master_registry.start_session();
					for (int i=2; i<argc; i+=2){
						const char *var = argv[i];
						const char *val = argv[i+1];
						if (master_registry.set(var,val) == -1){
							fprintf (stderr,MSG_U(E_NOTSET
								,"Variable %s was not set\n"),var);
						}
					}
					master_registry.end_session();
				}
			}else if (strcmp(arg,"--rundialog")==0){
				if (argc != 3){
					::usage();
				}else{
					ret = master_registry.rundialog (argv[2]);
					if (ret == -1){
						fprintf (stderr,MSG_R(E_NOVAR),argv[2]);
					}
				}
			}else if (strcmp(arg,"--help")==0){
				::usage();
			}else{
				fprintf (stderr,MSG_U(E_IVLDOPT,"Unknown option %s\n"),arg);
				::usage();
			}
		}
	}
	return ret;
}


static MODULE_vregistry vregistry;

#