/*
	Front-end to compile .tlcc program.
	Works like gcc so one can do

	cctlcc toto.tlcc -o toto
or
	cctlcc -c toto.tlcc -o toto.o

	.tlcc are converted to .cpp files and then deleted
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <limits.h>
#include <sys/wait.h>
#include <sys/stat.h>

static void check_exist (const char *path)
{
	struct stat st;
	if (lstat(path,&st)!=-1){
		fprintf (stderr,"file %s exist, won't overwrite, aborting\n",path);
		exit (-1);
	}
}

static bool debug = false;

static int cctlcc_execvp (const char *argv0, const char *argv[])
{
	if (debug){
		fprintf (stderr,"execvp %s:",argv0);
		for (int i=0; argv[i] != NULL; i++) fprintf (stderr," %s",argv[i]);
		fprintf (stderr,"\n");
	}
	return execvp (argv0,(char**)argv); 
}

static int cctlcc_exec (
	const char *cmd,
	const char *arg1,
	const char *arg2,
	const char *opts[])
{
	int ret = 0;
	pid_t pid = fork();
	if (pid == 0){
		int nb=0;
		if (opts != NULL) for (; opts[nb] != NULL; nb++);
		const char *argv[nb+4];
		argv[0] = cmd;
		for (int i=0; i<nb; i++) argv[i+1] = opts[i];
		argv[nb+1] = arg1;
		argv[nb+2] = arg2;
		argv[nb+3] = NULL;
		// for (int i=0; i<nb+3; i++) fprintf (stderr,"argv[%d]=%s\n",i,argv[i]);
		cctlcc_execvp (argv[0],argv);
	}else if (pid == (pid_t)-1){
		ret = -1;
		fprintf (stderr,"Can't fork (%s)\n",strerror(errno));
	}else{
		int status;
		while (wait(&status)!=-1);
		if (WIFEXITED(status)) ret = WEXITSTATUS(status);
	}
	return ret;
}

struct FILE_PATHS{
	char version[PATH_MAX];		// File showing required component version
	char tlcc[PATH_MAX];		// tlcc source file
	char tmp_tlcc[PATH_MAX];	// Temp tlcc source file produced from an hcc file
	char tmp_version[PATH_MAX];	// File showing all current component versions
								// (produced by tlccversion)
	char cpp[PATH_MAX];
	FILE_PATHS(const char *fname);
	int make_tmp_version(const char *fname, bool tlmpoptions, const char *cppoptions);
	int make_cpp (const char *fname, const char *source);
	int make_tmp_tlcc (const char *fname);
};

/*
	Produce all the various file names and temporary file names needed
	to produce the final .cpp file
*/
FILE_PATHS::FILE_PATHS(const char *fname)
{
	const char *end = strrchr(fname,'.');
	version[0] = tlcc[0] = tmp_version[0] = cpp[0] = '\0';
	if (end != NULL){
		strncpy (version,fname,sizeof(version)-1);
		strncpy (cpp,fname,sizeof(cpp)-1);
		strncpy (tlcc,fname,sizeof(tlcc)-1);
		int len = (int)(end - fname);
		strcpy (cpp+len,".cpp");
		strcpy (version+len,".version");
		strcpy (tlcc+len,".tlcc");
		const char *sl = strrchr(version,'/');
		if (sl == NULL){
			sl = version;
		}else{
			sl++;
		}
		snprintf (tmp_version,sizeof(tmp_version),"/tmp/%s.%d",sl,getpid());
		sl = strrchr(tlcc,'/');
		if (sl == NULL){
			sl = tlcc;
		}else{
			sl++;
		}
		snprintf (tmp_tlcc,sizeof(tmp_tlcc),"/tmp/%s.%d",sl,getpid());
	}
}
/*
	We extract in a temp file the list of all TLMP component visible
	by this source file and their corresponding version.

	Later, when we compile the turn the tlcc file into cpp, we use
	the proper component version based on

		-The source-file.version, built by the programmer to impose
		 the section of specific components version.
		-The TLMP.version file in the source directory, again
		 built by the programmer (or by the packager) to select
		 the proper components version.
		-The temp file built here, acting as the default.

*/

int FILE_PATHS::make_tmp_version(
	const char *fname,
	bool tlmpoptions,		// Use preset tlmp compilation options
	const char *cppoptions)	// Other preprocessor options to use
{
	check_exist (tmp_version);
	char tmpoptions[strlen(cppoptions)+200];
	if (tlmpoptions){
		snprintf (tmpoptions,sizeof(tmpoptions)-1
			,"%s -DEXPORT= -I/usr/include/tlmp -I/usr/include/linuxconf"
			,cppoptions);
	}else{
		strcpy (tmpoptions,cppoptions);
	}
	const char *cppopts[]={"--cppoptions",tmpoptions,NULL};
	return cctlcc_exec ("tlccversion",fname,tmp_version,cppopts);
}

int FILE_PATHS::make_cpp(const char *fname, const char *source)
{
	const char *tlccopts[]={
		"--compvers",tmp_version,
		"--compvers","TLMP.version",
		"--compvers",version,
		"--name",fname,
		NULL
	};
	check_exist (cpp);
	return cctlcc_exec ("tlcc",source,cpp,tlccopts);
}

int FILE_PATHS::make_tmp_tlcc (const char *fname)
{
	check_exist (tmp_tlcc);
	return cctlcc_exec ("tlmpwebcc",fname,tmp_tlcc,NULL);
}


int main (int argc, char *argv[])
{
	int ret = -1;
	if (argc <= 1){
		fprintf (stderr
			,"cctlcc: tlmp gcc wrapper\n"
			 "\n"
			 "\tIt translates .tlcc files into .cpp C++ files\n"
			 "\tand calls the C++ compiler to complete the tasks.\n"
			 "\tAll option are passed to the C++ compiler. cctlcc has\n"
			 "\tno option of its own.\n"
			 "\n"
			 "\tBy default \"gcc\" is used as the C++ compiler.\n"
			 "\tThis may be overriden by setting the environment variable\n"
			 "\tCC: CC=g++ cctlcc ... foo.tlcc ...\n"
			 "\n"
			);
	}else{
		char *newargv[argc+10];
		char *tmpfiles[3*argc+1];
		int nbtmp = 0;
		int lenopt = 0;
		for (int i=1; i<argc; i++) lenopt += strlen(argv[i])+1;
		char cppoptions[lenopt+1];
		cppoptions[0] = '\0';
		bool tlmpoptions = true;
		bool c_opt_seen = false;	// Are we only compiling a source file
									// (using -c) or we are also linking
		bool fpic_seen = false;
		int insert_cpp_option = 1;	// Where to insert preprocessor options
									// for tlmp
		int dst = 1;
		ret = 0;
		for (int i=1; i<argc && ret == 0; i++){
			char *arg = argv[i];
			if (strcmp(arg,"--notlmpoptions")==0){
				tlmpoptions = false;
			}else if (strcmp(arg,"--debug")==0){
				debug = true;
			}else if (strncmp(arg,"-I",2)==0
				|| strncmp(arg,"-D",2)==0){
				strcat (cppoptions," ");
				strcat (cppoptions,arg);
				newargv[dst++] = strdup(arg);
				insert_cpp_option = dst;
			}else if (strcmp(arg,"-c")==0){
				newargv[dst++] = strdup(arg);
				c_opt_seen = true;
			}else if (strcmp(arg,"-fPIC")==0){
				newargv[dst++] = strdup(arg);
				fpic_seen = true;
			}else if (strncmp(arg,"-o",2)==0){
				if (arg[2] == '\0'){
					newargv[dst++] = strdup(arg);
					arg = argv[++i];
				}
				if (arg != NULL){
					newargv[dst++] = strdup(arg);
					const char *end = strrchr(arg,'.');
					if (end != NULL && strcmp(end,".hc")==0){
						newargv[dst++] = strdup("-shared");
						newargv[dst++] = strdup("-Wl,-soname,hc.so.1");
					}
				}
			}else{
				const char *endtlcc = strstr(arg,".tlcc");
				const char *endhcc = strstr(arg,".hcc");
				if (endtlcc != NULL && endtlcc[5] == '\0'){
					FILE_PATHS paths (arg);
					// We must convert this file in .cc using the tlcc utility

					ret |= paths.make_tmp_version(arg,tlmpoptions,cppoptions);
					tmpfiles[nbtmp++] = strdup(paths.tmp_version);

					ret |= paths.make_cpp (arg,arg);

					newargv[dst++] = strdup(paths.cpp);
					tmpfiles[nbtmp++] = strdup(paths.cpp);
				}else if (endhcc != NULL && endhcc[4] == '\0'){
					if (!fpic_seen){
						newargv[dst++] = strdup("-fPIC");
						fpic_seen = true;
					}
					FILE_PATHS paths (arg);
					// We must convert this file in .cc using the tlcc utility

					ret |= paths.make_tmp_version(arg,tlmpoptions,cppoptions);
					tmpfiles[nbtmp++] = strdup(paths.tmp_version);

					ret |= paths.make_tmp_tlcc (arg);
					tmpfiles[nbtmp++] = strdup(paths.tmp_tlcc);

					ret |= paths.make_cpp (arg,paths.tmp_tlcc);

					newargv[dst++] = strdup(paths.cpp);
					tmpfiles[nbtmp++] = strdup(paths.cpp);
				}else{
					newargv[dst++] = strdup(arg);
				}
			}
		}
		newargv[dst] = NULL;
		{
			char *gcc = (char*)getenv ("CC");
			newargv[0] = gcc == NULL ? (char*)"gcc" : gcc;
		}
		if (ret == 0){
			pid_t pid = fork();
			if (pid == 0){
				if (tlmpoptions){
					const char *moreargv[dst+1+4];
					int skip = 0;
					moreargv[0] = newargv[0];
					for (int i=1; i<=dst; i++){
						if (i==insert_cpp_option){
							moreargv[i] = "-DEXPORT=";
							moreargv[i+1] = "-I/usr/include/tlmp";
							moreargv[i+2] = "-I/usr/include/linuxconf";
							skip = 3;
						}
						moreargv[i+skip] = newargv[i];
					}
					if (!c_opt_seen){
						moreargv[dst+skip] = "-llinuxconf";
						moreargv[dst+skip+1] = NULL;
					}
					//for (int i=0; i<dst+skip; i++) fprintf (stderr,"arg[%d]=%s\n",i,moreargv[i]);
					cctlcc_execvp (moreargv[0],moreargv);
				}else{
					cctlcc_execvp (newargv[0],(const char**)newargv);
				}
				fprintf (stderr,"Can't execute gcc (%s)\n",strerror(errno));
				_exit (-1);
			}else if (pid == (pid_t)-1){
				fprintf (stderr,"Can't fork (%s)\n",strerror(errno));
			}else{
				int status;
				while (wait(&status)!=-1);
				if (WIFEXITED(status)){
					ret = WEXITSTATUS(status);
				}
			}
		}
		for (int i=0; i<nbtmp; i++){
			char *tmpfile = tmpfiles[i];
			//fprintf (stderr,"unlink %s\n",tmpfile);
			unlink (tmpfile);
			free (tmpfile);
		}
	}
	return ret;
}