#pragma implementation
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdarg.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <limits.h>
#include "internal.h"
#include <vector>
#include <map>
#include <string>

using namespace std;

#if defined (unix)
	#include <sys/mman.h>
	#define O_BINARY	0
	static const char *translat_readall(int fd, int size)
	{
		return (const char*)mmap(0,size,PROT_READ,MAP_SHARED,fd,0);
	}

#else
	#if defined (UNIX)
		// Just to test the DOS/Windows mode in Unix.
		#include <unistd.h>
		#define O_BINARY	0
	#else
		#include <io.h>
	#endif
	static const char *translat_readall(int fd, int size)
	{
		char *ptm = (char*)malloc(size);
		if (ptm != NULL){
			if (read(fd,ptm,size)!=size){
				fprintf (stderr,"Can't read messages database\n");
			}
		}else{
			fprintf (stderr,"Can't allocate memory for messages\n");
		}
		close (fd);
		return ptm;
	}

#endif
#include "translat.h"

static TRANSLATE_SYSTEM_REQ *first = NULL;

PUBLIC TRANSLATE_SYSTEM_REQ::TRANSLATE_SYSTEM_REQ(
	const char *_sysname,
	const char **&_global_var,	// Will point to an array
					// of message (char*)
	int _nb_expected,
	int _version)
	: global_var (_global_var)
{
	nb_expected = _nb_expected;
	version = _version;
	/* #Specification: translate / dictionnary request
		A dictionnary request is done simply by declaring
		a static variable of type TRANSLATE_SYSTEM_REQ.
		We generally defined this variable in the
		source module which is always used within a system.

		Sometime, there is no such a module but indeed a few
		module (A library) which are candidate to be included
		in every program which use the librairy.

		It is possible to declare several static
		TRANSLATE_SYSTEM_REQ, one in every module we need. These
		request should use obviously the same name and
		the same global variable.

		Special macros are automagically defined by
		msgscan to insure consistency.
	*/
	TRANSLATE_SYSTEM_REQ *pt = first;
	while (pt != NULL){
		if (strcmp(pt->sysname,_sysname)==0)break;
		pt = pt->next;
	}
	if (pt == NULL){
		next = first;
		first = this;
		sysname = _sysname;
	}
}
static char *pterr = NULL;
#define MAXERR_SIZE 2000
/*
	Print an error message and increment the err counter
*/
static void translat_err (const char *msg, ...)
{
	va_list list;
	va_start (list,msg);
	pterr += vsnprintf (pterr,MAXERR_SIZE,msg,list);
	va_end (list);
}

struct LANGS{
	vector<const char **> langs;
	LANGS(){
		langs.push_back(NULL);
		langs.push_back(NULL);
	}
};
static map<const char ***,LANGS> lang_switch;


static void translat_alloc (
	BDICT_SYSTEM *tbsys,
	int nbsys,
	const char *base_file,	// Start of mmap file
	const char *ptm,	// start of indexes
	unsigned langnum)	// Lang number for multiple language support (web apps)
{
	/*
		The static variable "first" points to a linked list of
		TRANSLATE_SYSTEM_REQ. Each member corresponds to a dictionary
		to load.
	
		OLD
		If we find a given dictionary in tbsys, then
		we remove the TRANSLATE_SYSTEM_REQ object from the linked list.
		Ultimatly, first wiil point to NULL.
		/OLD

		This strategy allows various things
		
		-One program may be composed of several dictionaries (one
		 per directory generally)
		-One program may spread its dictionaries in several message
		 files. This is especially useful when you are using various
		 libraries where each one supplies its own message file.
		 translat_alloc will be called several times.
		-One program (linuxconf for one) may have its own message file
		 and each module provides also its message file.
	*/
	TRANSLATE_SYSTEM_REQ *req = first;
	while (req != NULL){
		unsigned offset = 0;
		BDICT_SYSTEM *ptsys = tbsys;
		int i;
		for (i=0; i<nbsys; i++, ptsys++){
			int nbmsg = ptsys->nbmsg;
			if (strcmp(req->sysname,ptsys->name)==0){
				if (req->version > ptsys->version){
					translat_err ("sub-dictionnary %s: Invalid version %d < %d\n"
						,req->sysname,ptsys->version,req->version);
				}else if (req->nb_expected > ptsys->nbmsg){
					translat_err ("sub-dictionnary %s: Not enough messages %d < %d\n"
						,req->sysname,ptsys->nbmsg,req->nb_expected);
				}else{
					req->global_var = (const char**)malloc(nbmsg*sizeof(char*));
					lang_switch[&req->global_var].langs[langnum] = req->global_var;
					const char **ptvar = req->global_var;
					unsigned *ptoff = (unsigned*)(ptm + offset);
					for (int m=0; m<nbmsg; m++, ptvar++, ptoff++){
						*ptvar = base_file + ntohl(*ptoff);
						// printf ("%s-%d: %p %p\n",ptsys->name,m,base_file,*ptvar);
					}
				}
				break;
			}else{
				offset += nbmsg * sizeof(unsigned);
			}
		}
		req = req->next;
	}
}
/*
	Read a BDICT_HEADER in a binary compatible way on all architecture
	Return the pointer at the end of BDICT_HEADER in the buffer
*/
static 	const char *translat_readheader (
	const char *ptm,
	BDICT_HEADER &hd)
{
	unsigned short *val = (unsigned short*)ptm;
	hd.magic = ntohs (val[0]);
	hd.version = ntohs (val[1]);
	hd.nbsys = ntohs (val[2]);

	// printf ("magic = %x version = %x nbsys = %x\n",hd.magic,hd.version,hd.nbsys);
	return ptm+6;
}

/*
	Read a BDICT_SYSTEM in a binary compatible way on all architecture
	Return the pointer at the end of BDICT_SYSTEM in the buffer
*/
static 	const char *translat_readsys (
	const char *ptm,
	BDICT_SYSTEM &sys)
{
	strcpy (sys.name,ptm);
	ptm += sizeof(sys.name);
	unsigned short *val = (unsigned short*)ptm;
	sys.version = ntohs (val[0]);
	sys.nbmsg = ntohs (val[1]);
	return ptm+4;
}


static string default_lang = "eng";
static vector<string> search_path;
/*
	Load the message dictionnary.
	Terminate the application if any error.
*/
static int translat_loaderr (
	const char *basename,	// base name of the dictionnary
				// the language selection will supply
				// the extension.
	const char *lang,
	unsigned langnum,
	char errmsg[MAXERR_SIZE])			// Will contain the error message
{
	int ret = -1;
	errmsg[0] = '\0';
	pterr = errmsg;
	bool showerr = getenv ("SHOWDICERR")!=NULL;
	for (unsigned i=0; i<search_path.size(); i++){
		char path[PATH_MAX];
		snprintf (path,sizeof(path)-1,"%s.%s/%s.%s",search_path[i].c_str(),lang,basename,lang);
		int fd  = open (path,O_BINARY|O_RDONLY);
		if (fd == -1){
			if (showerr){
				fprintf (stderr,"translat_loaderr open failed i=%u path=%s\n",i,path);
			}
			if (i == search_path.size()-1){
				translat_err ("Can't load dictionnary file %s (%s)\n"
					,path,strerror (errno));
			}
		}else{
			struct stat64 st;
			if (stat64 (path,&st)==-1){
				translat_err ("Can't stat dictionnary file %s (%s)\n"
					,path,strerror(errno));
			}else{
				const char *ptm = translat_readall (fd,st.st_size);
				if (ptm != NULL){
					const char *start_ptm = ptm;;
					BDICT_HEADER hd;
					ptm = translat_readheader (ptm,hd);
					if (hd.magic != BDICT_MAGIC){
						translat_err ("Invalid dictionnary magic word: %s\n",path);
					}else if (hd.version != BDICT_VERSION){
						translat_err ("Invalid dictionnary version: %s\n",path);
					}else{
						BDICT_SYSTEM tbsys[hd.nbsys];
						for (int i=0; i<hd.nbsys; i++){
							ptm = translat_readsys (ptm,tbsys[i]);
						}
						while  (((start_ptm - ptm) % sizeof(int32_t)) != 0) ptm++;
						translat_alloc (tbsys,hd.nbsys,start_ptm,ptm,langnum);
					}
				}
			}
			ret = pterr > errmsg ? -1 : 0;
			break;
		}
	}
	return ret;
}
static vector<string> tblang;
unsigned nblang = 0;

void translat_setlang (const char *lang)
{
	static bool done_once = false;
	if (!done_once){
		done_once = true;
		default_lang = lang;
		nblang = str_splitline(lang,',',tblang);
	}
}
void translat_setdictdir (const char *path)
{
	bool found = false;
	for (unsigned i=0; i<search_path.size(); i++){
		if (strcmp(search_path[i].c_str(),path)==0){
			found = true;
			break;
		}
	}
	if (!found){
		search_path.push_back(path);
	}
}

void translat_load (const char *basename)
{
	char errmsg[MAXERR_SIZE];
	const char *def_lang = default_lang.c_str();
	if (nblang > 1){
		// Load several langs at once (used for web application)
		for (unsigned i=0; i<nblang; i++){
			translat_loaderr(basename,tblang[i].c_str(),i,errmsg);
		}
	}else{
		if (translat_loaderr(basename,def_lang,0,errmsg)==-1){
			if (strcmp(def_lang,"eng")!=0){
				if (translat_loaderr(basename,"eng",0,errmsg)==-1){
					fprintf (stderr,"%s",errmsg);
					exit (-1);
				}
			}else{
				fprintf (stderr,"%s",errmsg);
				exit (-1);
			}
		}
	}
}
#if 0
/*
	Load the message dictionnary.
	Terminate the application if any error.
*/
void translat_load (
	const char *basepath,	// Directory holding dictionnaries
	const char *basename,	// base name of the dictionnary
							// the language selection will supply
							// the extension.
	const char *lang)
{
	char errmsg[MAXERR_SIZE];
	translat_setdictdir(basepath);
	if (translat_loaderr (basename,lang,errmsg)==-1){
		fprintf (stderr,"%s",errmsg);
		exit (-1);
	}
}

/*
	Load the message dictionnary.
	Terminate the application if any error.
*/
void translat_load (
	const char *basepath,	// Default directory holding dictionnaries
	const char *envdirvar,	// Environment variable to override basepath
	const char *basename,	// base name of the dictionnary
							// the language selection will supply
							// the extension.
	const char *envlangvar,	// Environment variable to override the
							// language
	const char *deflang)	// Default language
{
	/* #Specification: messages dictionnary / location / strategy
		The application specify the location and the default language
		for the message dictionnary. This is supplied as a basepath and a
		basename. The effective path of the dictionnary is

		#
		basepath/basename.lang
		#

		An environnement variable let you override the base path and another
		environnement variable let you override the language. For the
		linuxconf project, the environnement variables are for example.
	
		#
		LINUXCONF_DICT: base path
		LINUXCONF_LANG: language extension
		#

		The basepath may be overriden only if "geteuid() == getuid()"
		for security reason.
	*/
	if (geteuid() == getuid()){
		char *en = getenv (envdirvar);
		if (en != NULL) basepath = en;
	}
	translat_setdictdir(basepath);

	const char *lang = deflang;
	const char *lang_env = getenv(envlangvar);
	if (lang_env != NULL && strlen(lang_env)<=5) lang = lang_env;

	char errmsg[MAXERR_SIZE];
	if (translat_loaderr (basename,lang,errmsg)==-1){
		if (strcmp(lang,"eng")!=0){
			bool showerr = getenv ("SHOWDICERR")!=NULL;
			if (showerr){
				fprintf (stderr,"%s",errmsg);
				fprintf (stderr,"Switching to english\n");
			}
			translat_loaderr (basename,"eng",errmsg);
		}else{
			fprintf (stderr,"%s",errmsg);
			exit(-1);
		}
	}
}
#endif
/*
	Make sure that all message dictionaries are loaded
*/
void translat_checkmissing()
{
	bool some_missing = false;
	TRANSLATE_SYSTEM_REQ *req = first;
	while (req != NULL){
		if (lang_switch.find(&req->global_var) == lang_switch.end()){
			some_missing = true;
			fprintf (stderr,"Unknown dictionnary %s\n",req->sysname);
		}
		req = req->next;
	}
	if (some_missing) exit(-1);
	for (map<const char ***,LANGS>::iterator it=lang_switch.begin(); it != lang_switch.end(); it++){
		for (unsigned i=1; i<it->second.langs.size(); i++){
			if (it->second.langs[i] == NULL) it->second.langs[i] = it->second.langs[0];
		}
	}
}

void translat_selectlang(const char *lang)
{
	unsigned nolang = 0;
	for (unsigned i=0; i<nblang; i++){
		if (strcmp(lang,tblang[i].c_str())==0){
			nolang = i;
			break;
		}
	}
	for (map<const char ***,LANGS>::iterator it=lang_switch.begin(); it != lang_switch.end(); it++){
		(*it->first) = it->second.langs[nolang];
	}
}