#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include "../tlmplib/tlmplib.h"
#include "tlmpdia.h"
#include <diajava.h>
#include <netdb.h>
#include <string>
#include <set>

using namespace std;

// #Specbeg: editrecords / sample
/*
	Here is a typical/simple application.
*/
<mod>
static void samples_editrecords(int nb)
{
	<glocal>
		int nb;
	</glocal>
	glocal.nb = nb;
	<call editrecords>("records","Some records",help_nil);
		<f head>
			newf_head ("ID\tDescription\tDate");
		</f>
		<f load>
			for (int i=0; i<glocal.nb; i++){
				char buf1[100],buf2[100];
				sprintf (buf1,"%03d",i);
				sprintf (buf2,"This is record %d\t24/10/2000",i);
				new_menuitem (buf1,buf2);
			}
		</f>
		<f editone>
			xconf_notice ("Editing record %d",no);
		</f>
	</call>
}
</mod>
// #Specend:

// #Specbeg: editrecords / sample / sorted
/*
	Here is a typical/simple application showing column sorting.
*/
<mod>
static void samples_editrecords_sorted(int nb)
{
	<glocal>
		int nb;
	</glocal>
	glocal.nb = nb;
	<call editrecords>("records","Some sortable records",help_nil);
		<f head>
			newf_head ("ID\tDescription\tDate");
			sortable();
		</f>
		<f load>
			// We sort each colums independantly (no useful)
			SSTRINGS nums,descs,dates;			
			for (int i=0; i<glocal.nb; i++){
				char buf1[100];
				sprintf (buf1,"%03d",i);
				nums.add (new SSTRING(buf1));
				SSTRING *s = new SSTRING;
				s->setfromf ("This is record %d",i);
				descs.add (s);
				s = new SSTRING;
				s->setfromf ("%02d/10/2000",i);
				dates.add (s);
			}
			if (order != SORT_NONE){
				switch (column){
				case 0:
					nums.sort();
					break;
				case 1:
					descs.sort();
					break;
				case 2:
					dates.sort();
					break;
				};
				if (order == SORT_DESC){
					nums.invert();
					descs.invert();
					dates.invert();
				}
			}
			for (int i=0; i<glocal.nb; i++){
				new_menuitemf (nums.getitem(i)->get(),"%s\t%s"
					,descs.getitem(i)->get(),dates.getitem(i)->get());
			}
		</f>
		<f editone>
			xconf_notice ("Editing record %d",no);
		</f>
		<f clickhead>
			if (state.leftb){
				selectsort (head);
			}else if (state.rightb){
				// Contextual menu
				xconf_notice ("Put a popup here");
			}
		</f>
	</call>
}
</mod>
// #Specend:

// #Specbeg: sample / uithread / principles
/*
	Sometime we which to have two dialogs at once (consider the FRAMEWORK
	component if you wish to do that). The uithread function is handy
	but the uithread TLMP component is easier to handle. It triggers
	up to 3 threads and waits for their completion. As such is allows
	the various threads to share glocal,
*/
static void sample_dialog(const char *title)
{
	DIALOG dia;
	SSTRING s;
	dia.newf_str ("field1",s);
	dia.edit (title,"",help_nil);
}

<mod>
static void sample_uithread()
{
	<call uithread>();
	<f thread1>
		sample_dialog("dialog thread1");
	</f>
	<f thread2>
		sample_dialog("dialog thread2");
	</f>
	<f thread3>
		sample_dialog("dialog thread3");
	</f>
	</call>
	xconf_notice ("All threads done");
}
</mod>

// #Specend:
// #Specbeg: sample / uithread / updating a dialog
/*
	The following example grab the information produced by a process and
	fill a table (editrecord). One uithread is used to collect the data
	and a PRIVATE_MESSAGE is used to signal the editrecord thread.

	This sample also show how one thread may ask another to end using
	PRIVATE_MESSAGE.
*/

<mod>
static void sample_uithread_popen()
{
	glocal SSTRINGS data;
	glocal PRIVATE_MESSAGE samples,ending;
	dialog_clear();

	<call uithread>();
	<f thread1>
		<call walkpopen>("/tmp/x output 100",1,true);
		<f wait>
			/*
				We are using diagui_sync() to make sure the other dialog
				are still alive.
			*/
			int ret = diagui_sync (pop,timeout,true);
			if (dialog_testmessage(glocal.ending)){
				end = true;
				pop.kill();
			}
			return ret;
		</f>
		<f oneline>
			glocal.data.add (new SSTRING(line));
			dialog_sendmessage (glocal.samples);
		</f>
		</call>
	</f>
	<f thread2>
		<call editrecords>("Some records","",help_nil);
		<f head>
			waitfor (glocal.samples);
			newf_head ("column1\tcolumn2\tcolumn3");
			setvsize (10);
		</f>
		<f load>
			for (int i=0; i<glocal.data.getnb(); i++){
				const char *s = glocal.data.getitem(i)->get();
				char tmp[strlen(s)+1];
				strcpy (tmp,s);
				char *pt = tmp;
				while (*pt != '\0'){
					if (*pt == ' ') *pt = '\t';
					pt++;
				}
				SSTRING word;
				pt = str_copyword (word,tmp);
				new_menuitem (word.get(),pt);
			}
		</f>
		<f editone>
			printf ("Line %d was selected\n",no);
		</f>
		</call>
		dialog_sendmessage (glocal.ending);
	</f>
	</call>
}
</mod>
// #Specend:

/*
	Function used by the preceding example. It generates a new line
	every 2 seconds.
*/

static void sample_output (int nb)
{
	for (int i=0; i<nb; i++){
		printf ("line%d.1 line%d.2 line%d.3\n",i,i,i);
		fflush (stdout);
		sleep(2);
	}
}


// #Specbeg: sample / formtmp component
/*
	We use the formtmp component as a way to isolate parts of a program
	which either take a long time to complete, or use a large amount
	of ram. In the later case, if the program does a lot of malloc and
	corresponding free, it may end up using a lot of ram since returning
	the memory to the OS is not always possible. One may use forktmp()
	to avoid growing the memory footprint of a long live process.

	By using the forktmp component, one can isolate some area
	of the program while having simple way to communicate results
	back.

	Using the SHAREMEM template and glocal variable, it become
	very easy to use a sub-process and grab the results easily.
	You simply define a type and both side of the forktmp()
	component (parent and child process) may use it.
*/
/*
	The following example demonstrate using the gethostbyname
	function and a little dialog to control the execution.
*/

struct X{
		bool found;
		int duree;
		int addr[4];
		X(){
fprintf (stderr,"Contruit X\n");
			found = false;
			duree = 0;
			memset(addr,0,sizeof(addr));
		}
	};
<mod>
static void sample_fork(
	const char *arg,
	PRIVATE_MESSAGE &msg,
	bool &cmd,
	int &progress,
	PRIVATE_MESSAGE &progress_msg)
{
	fprintf (stderr,"Starting\n");
	glocal SHAREMEM<X> a;
	glocal bool *cmd = &cmd;
	glocal int *progress = &progress;
	glocal PRIVATE_MESSAGE *progress_msg = &progress_msg;
	fprintf (stderr,"Starting sharemem done\n");

	// We are doing an nslookup on a name. This may time out
	glocal const char *name = arg;
	<call forktmp>(1,msg);
	<f task>
		fprintf (stderr,"Sync with the parent\n");
		join(0);
		fprintf (stderr,"Sync done\n");
		struct hostent *ent = gethostbyname(glocal.name);
		if (ent == NULL){
			glocal.a.p.found = false;
		}else{
			glocal.a.p.found = true;
			glocal.a.p.addr[0] = ent->h_addr[0];
			glocal.a.p.addr[1] = ent->h_addr[1];
			glocal.a.p.addr[2] = ent->h_addr[2];
			glocal.a.p.addr[3] = ent->h_addr[3];
		}
	</f>
	<f timeout>
		fprintf (stderr,"%d seconds so far\n",duration);
		(*glocal.progress)++;
		dialog_sendmessage(*glocal.progress_msg);
		glocal.a.p.duree = duration;
		if (duration > 100) end = true;
	</f>
	<f message>
		fprintf (stderr,"Some message cmd=%d\n",*glocal.cmd);
		if (*glocal.cmd){
			kill();
		}
	</f>
	<f joining>
		fprintf (stderr,"The child is joining\n");
	</f>
	</call>
	if (glocal.a.p.found){
		fprintf (stderr,"Name found addr=%d.%d.%d.%d\n"
		,glocal.a.p.addr[0]
		,glocal.a.p.addr[1]
		,glocal.a.p.addr[2]
		,glocal.a.p.addr[3]);
	}else{
		fprintf (stderr,"Name not found\n");
	}
}
</mod>

<mod>
static void sample_fork(const char *arg)
{
	// We repeat 5 time to test for various resources leaks
	for (int i=0; i<5; i++){
		glocal PRIVATE_MESSAGE msg;
		glocal const char *arg = arg;
		glocal bool cmd = false;
		glocal PRIVATE_MESSAGE done;
		glocal PRIVATE_MESSAGE progress_msg;
		glocal int progress = 0;
		<call uithread>();
		<f thread1>
			DIALOG dia;
			dia.newf_chk ("Terminate",glocal.cmd,"nslookup");
			int gauge = dia.size();
			dia.newf_gauge ("Duration",glocal.progress,40);
			dia.waitfor (glocal.done);
			dia.waitfor (glocal.progress_msg);
			while (1){
				MENU_STATUS code = dia.edit ("Click a button","",help_nil);
				if (code == MENU_CANCEL){
					break;
				}else if (code == MENU_MESSAGE){
					if (dialog_testmessage(glocal.done)){
						break;
					}else if (dialog_testmessage(glocal.progress_msg)){
						dia.reload(gauge);
					}
				}else{
					dialog_sendmessage (glocal.msg);
				}
			}
		</f>
		<f thread2>
			sample_fork (glocal.arg,glocal.msg,glocal.cmd
				,glocal.progress,glocal.progress_msg);
			dialog_sendmessage(glocal.done);
		</f>
		</call>
	}
}
</mod>

// #Specend:

// #Specbeg: sample / formtmp component / fault
/*
	The following example shows one usage of forktmp(). Since it is
	easy to communicate between a child and a parent using SHAREMEM, it
	is convenient to shield a program from a potentially sensitive part.

	Or said differently, all program have bugs, so by isolating
	various area, the core of the program may continue to operate
	even if a child fail (segfault).

	While this does not seem clean (bug should be fixed, no ?), building
	software against its own flaws may be a solution sometime.

	The following example shows a simple tasks which immediatly segfault.
	It presents the default behavior of the failed functag.
*/


<mod>
static void sample_forkfault()
{
	<call forktmp>();
	<f task>
		char *pt = NULL;
		*pt = '\0';
	</f>
	</call>
}
</mod>

// #Specend:



<mod>
int main (int argc, char *argv[])
{
	<glocal>
	</glocal>
	int ret = <call tlmpprogram>(argc, argv,"linuxconf");
	<f usage>
		fprintf (stderr,"/tmp/x records\n");
		fprintf (stderr,"/tmp/x records-sorted\n");
		fprintf (stderr,"/tmp/x tree\n");
		fprintf (stderr,"/tmp/x uithread\n");
		fprintf (stderr,"/tmp/x uithreadpopen\n");
		fprintf (stderr,"/tmp/x fork\n");
		fprintf (stderr,"/tmp/x forkfault\n");
	</f>
	<f main>
		if (argc < 1){
			usage();
		}else if (strcmp(argv[0],"records")==0){
			samples_editrecords(15);
		}else if (strcmp(argv[0],"records-sorted")==0){
			samples_editrecords_sorted(15);
		}else if (strcmp(argv[0],"uithread")==0){
			dialog_clear();
			sample_uithread();
		}else if (strcmp(argv[0],"uithreadpopen")==0){
			sample_uithread_popen();
		}else if (strcmp(argv[0],"output")==0){
			sample_output (atoi(argv[1]));
		}else if (strcmp(argv[0],"fork")==0){
			dialog_clear();
			sample_fork (argv[1]);
		}else if (strcmp(argv[0],"forkfault")==0){
			dialog_clear();
			sample_forkfault ();
		}else if (strcmp(argv[0],"tree")==0){
			/*
				This sample code evolved to test edittree and the
				treemenu widget in the GUI. Maybe less and less relevant.
				It shows how the set_lookup() function may be used to
				connect editone event easily.
			*/
			glocal int nb = 3;
			glocal set<string> are_set;	// Those must be highlited
			glocal set<string> nb_set;	// We must increase the number of child
			glocal set<string> are_del;	// This node is deleted (not chown anymore)
			<call edittree>("tree","This is a tree",help_nil);
			<f load>
				for (int i=0; i<3; i++){
					char buf[100];
					sprintf (buf,"root-%d",i);
					if (glocal.are_del.count(buf)==0){
						new_file (buf);
						set_lookup(buf);
					}
				}
				for (int i=0; i<glocal.nb; i++){
					char buf[100];
					sprintf (buf,"dir%d",i);
					if (glocal.are_del.count(buf)==0){
						if (glocal.are_set.count(buf)>0){
							setnexttagged();
						}
						new_subdir (buf);
						set_lookup (buf);
						for (int j=0; j<2; j++){
							sprintf (buf,"dir%d.%d",i,j);
							if (glocal.are_del.count(buf)==0){
								if (glocal.are_set.count(buf)>0){
									setnexttagged();
								}
								new_subdir (buf);
								set_lookup (buf);
								int nbk = 2;
								if (glocal.nb_set.count(buf)>0) nbk = 4;
								for (int k=0; k<nbk; k++){
									sprintf (buf,"file%d.%d-%d",i,j,k);
									if (glocal.are_del.count(buf)==0){
										if (glocal.are_set.count(buf)>0){
											setnexttagged();
										}
										new_file (buf);
										set_lookup(buf);
									}
								}
								end_subdir();
							}
						}
						end_subdir ();
					}
				}
			</f>
			<f editone>
				if (uistate.shiftkey){
					if (glocal.are_set.count(key)>0){
						glocal.are_set.erase(key);
					}else{
						glocal.are_set.insert(key);
					}
				}else if (uistate.ctrlkey){
					if (glocal.nb_set.count(key)>0){
						glocal.nb_set.erase(key);
					}else{
						glocal.nb_set.insert(key);
					}
				}else if (uistate.rightb){
					// Once deleted, there gone, no way to undelete them
					glocal.are_del.insert(key);
				}else{
					xconf_notice ("Editing record %s level %d key=%s",spath,level,key);
				}
			</f>
			</call>
		}else{
			usage();
		}
		return 0;
	</f>
	</call>
	return ret;
}
</mod>