#include	<stdio.h>
#include	<Xm/CascadeB.h>
#include	<Xm/DrawingA.h>
#include	<Xm/Label.h>
#include	<Xm/MainW.h>
#include	<Xm/MessageB.h>
#include	<Xm/PushB.h>
#include	<Xm/RowColumn.h>
#include	<Xm/Scale.h>
#include	<Xm/Separator.h>
#include	<Xm/ToggleB.h>
#include	"ga.h"

XtAppContext	app_con;
Widget		app_sh;
Display		*dpy;
int	scr;
GC		gc;

String  fallback_resources[] = {
	"*GA.title:	2D Hill climbing",
	"*FontList:	*-helvetica-bold-r-*-140-75-*",
	"*background:	grey90",
	"*foreground:	black",
	"*mutationRate.titleString: mutation rate",
	"*crossoverRate.titleString: crossover rate",
	"*populationSize.titleString: population size",
	"*elitePercentage.titleString: elite percentage",
	"*Monitor.title: Evolutionary process",
	"*work.width:	400",
	"*work.height:	400",
	"*Monitor.work.foreground: white",
	"*Monitor.work.background: DarkGreen",
	NULL
};

Widget	MainWindow, MessageDialog = NULL;
show_message(msg)
char	*msg;
{
	XmString	str = XmStringCreateSimple(msg);
	int	n;
	Arg	args[6];
	n = 0; XtSetArg(args[n],XmNmessageString,str); n++;
	if (!MessageDialog) {
		MessageDialog = XmCreateMessageDialog(MainWindow,
			"message",args,n);
		XtUnmanageChild(XmMessageBoxGetChild(MessageDialog,
			XmDIALOG_HELP_BUTTON));
		XtUnmanageChild(XmMessageBoxGetChild(MessageDialog,
			XmDIALOG_CANCEL_BUTTON));
	} else XtSetValues(MessageDialog,args,n);
	XtManageChild(MessageDialog);
}
static Widget	GLabel, BLabel;
static Pixel	Gfg, Gbg;
static unsigned int	Gwidth, Gheight;
static int	Gx, Gy, Bx;
XFontStruct	*Gfont;
static void init_generation_window()
{
	Window	root;
	int	x,y;
	unsigned int	border,depth;
	XmFontList	fontList;
	XmFontContext	context;
	XmStringCharSet	charset;
	XGetGeometry(dpy,XtWindow(GLabel),&root,&x,&y,
		&Gwidth,&Gheight,&border,&depth);
	XtVaGetValues(GLabel,XmNforeground,&Gfg,XmNbackground,&Gbg,
		XmNfontList,&fontList,NULL);
	XmFontListInitFontContext(&context, fontList);
	XmFontListGetNextFont(context, &charset, &Gfont);
	Gx = XTextWidth(Gfont,"Generation ",11) + 2;
	Gy = Gheight - Gfont->max_bounds.descent - 2;
	Bx = XTextWidth(Gfont,"Best fitness ",13) + 2;
}
static void show_value(w,x,buf) Widget w; int x; char *buf;
{
	int	right = x + XTextWidth(Gfont,buf,strlen(buf));
	XSetForeground(dpy,gc,Gfg);
	XDrawImageString(dpy,XtWindow(w),gc,x,Gy,buf,strlen(buf));
	XSetForeground(dpy,gc,Gbg);
	XFillRectangle(dpy,XtWindow(w),gc,right,0,Gwidth-right,Gheight);
}
visualize()
{
	char	buf[16];
	extern	int	Generation;
	extern	double	*BestFitness;
	XSetBackground(dpy,gc,Gbg);
	XSetFont(dpy,gc,Gfont->fid);
	sprintf(buf,"%6d",Generation);
	show_value(GLabel,Gx,buf);
	fitness_string(BestFitness[Generation],buf);
	show_value(BLabel,Bx,buf);
	domain_draw();
}
static void reset_gui()
{
	reset_population();
	visualize();
}
typedef enum {
	BTCascadeButton,
	BTPushButton,
	BTToggleButton,
	BTSeparator,
	BTEnd
} button_type;

static Widget	(*buttonCP[])() = {
	XmCreateCascadeButton,
	XmCreatePushButton,
	XmCreateToggleButton,
	XmCreateSeparator
};

typedef	struct my_menu_rec {
	button_type type; char *label;
	XtCallbackProc proc; struct my_menu_rec *sub;
} my_button;

static void create_menus(parent,b) Widget parent; my_button *b;
{
	Widget	bt, menu;
	for (; b->label; b ++) {
		XtManageChild(bt=(*buttonCP[b->type])(parent,b->label,NULL,0));
		if (b->proc) XtAddCallback(bt,XmNactivateCallback,b->proc,NULL);
		if (b->sub) {
			menu = XmCreatePulldownMenu(bt,"menu",NULL,0);
			create_menus(menu,b->sub);
			XtVaSetValues(bt,XmNsubMenuId,menu,NULL);
		}
	}
}
static void c_quit(w,cl,cd) Widget w; XtPointer cl,cd; { exit(1); }
static void c_reset(w,cl,cd) Widget w; XtPointer cl,cd; { reset_gui(); }
static XtWorkProcId	Running = NULL;
static Boolean	one_step(cl) XtPointer cl;
{ one_generation(); if (cl) Running = NULL; return (Boolean)cl; }
static void c_run(w,cl,cd) Widget w; XtPointer cl,cd;
{ if (Running) { XtRemoveWorkProc(Running); Running = NULL; }
  else Running = XtAppAddWorkProc(app_con,one_step,False); }
static void c_step(w,cl,cd) Widget w; XtPointer cl,cd;
{ if (Running) { XtRemoveWorkProc(Running); Running = NULL; }
  else Running = XtAppAddWorkProc(app_con,one_step,(XtPointer)True); }
static void setSelectionCB(w,cl,cd) Widget w; XtPointer cl,cd;
{
	extern	selectionStrategy	SelectionStrategy;
	SelectionStrategy = (selectionStrategy)cl;
}
static void setCodingCB(w,cl,cd) Widget w; XtPointer cl,cd;
{
	extern	codingMethod	CodingMethod;
	CodingMethod = (codingMethod)cl;
}
static void setParamCB(w,cl,cd) Widget w; XtPointer cl,cd;
{
	int	value;
	XtVaGetValues(w,XmNvalue,&value,NULL);
	*((double *)cl) = value * .01;
}
static void setIntParamCB(w,cl,cd) Widget w; XtPointer cl,cd;
{
	XtVaGetValues(w,XmNvalue,(int *)cl,NULL);
}
static void setPopSizeCB(w,cl,cd) Widget w; XtPointer cl,cd;
{
	extern	int	PopulationSize;
	XtVaGetValues(w,XmNvalue,&PopulationSize,NULL);
	reset_gui();
}
static my_button
buttons[] = {
	{BTCascadeButton,"Quit",c_quit,NULL},
	{BTCascadeButton,"Reset",c_reset,NULL},
	{BTCascadeButton,"Run",c_run,NULL},
	{BTCascadeButton,"Step",c_step,NULL},
	{BTEnd,NULL}
};

static void create_command(parent) Widget parent;
{
	Widget	box, button, menu, scale;
	XmString	str;
	int	n, value;
	Arg	args[6];
	extern	double	MutationRate, CrossoverRate;
	extern	int	PopulationSize, ElitePercentage;

	XtManageChild(box=XmCreateRowColumn(parent,"column1",NULL,0));
	XtManageChild(GLabel=XmCreateLabel(box,"Generation",NULL,0));
	XtManageChild(BLabel=XmCreateLabel(box,"Best fitness",NULL,0));
	str = XmStringCreateSimple("Selection");
	menu = XmCreatePulldownMenu(box,"menu",NULL,0);
	n = 0; XtSetArg(args[n],XmNlabelString,str); n++;
	XtSetArg(args[n],XmNsubMenuId,menu); n++;
	XtManageChild(button=XmCreateOptionMenu(box,"Selection",args,n));
	XmStringFree(str);
	XtManageChild(button=XmCreatePushButton(menu,"roulette",NULL,0));
	XtAddCallback(button,XmNactivateCallback,
		setSelectionCB,RouletteSelection);
	XtManageChild(button=XmCreatePushButton(menu,"ranking",NULL,0));
	XtAddCallback(button,XmNactivateCallback,
		setSelectionCB,(XtPointer)RankingSelection);
	str = XmStringCreateSimple("Coding");
	menu = XmCreatePulldownMenu(box,"menu",NULL,0);
	n = 0; XtSetArg(args[n],XmNlabelString,str); n++;
	XtSetArg(args[n],XmNsubMenuId,menu); n++;
	XtManageChild(button=XmCreateOptionMenu(box,"Coding",args,n));
	XmStringFree(str);
	XtManageChild(button=XmCreatePushButton(menu,"binary",NULL,0));
	XtAddCallback(button,XmNactivateCallback,setCodingCB,BinaryCoding);
	XtManageChild(button=XmCreatePushButton(menu,"gray",NULL,0));
	XtAddCallback(button,XmNactivateCallback,
		setCodingCB,(XtPointer)GrayCoding);
	XtManageChild(button=XmCreatePushButton(menu,"integer",NULL,0));
	XtAddCallback(button,XmNactivateCallback,
		setCodingCB,(XtPointer)IntegerCoding);

	XtManageChild(box=XmCreateRowColumn(parent,"column2",NULL,0));
	n = 0; XtSetArg(args[n],XmNvalue,(int)(MutationRate*100)); n++;
	XtSetArg(args[n],XmNmaximum,100); n++;
	XtSetArg(args[n],XmNdecimalPoints,2); n++;
	XtSetArg(args[n],XmNorientation,XmHORIZONTAL); n++;
	XtSetArg(args[n],XmNscaleWidth,140); n++;
	XtSetArg(args[n],XmNshowValue,True); n++;
	XtManageChild(scale=XmCreateScale(box,"mutationRate",args,n));
	XtAddCallback(scale,XmNvalueChangedCallback,setParamCB,&MutationRate);
	XtSetArg(args[0],XmNvalue,(int)(CrossoverRate*100));
	XtManageChild(scale=XmCreateScale(box,"crossoverRate",args,n));
	XtAddCallback(scale,XmNvalueChangedCallback,setParamCB,&CrossoverRate);

	XtManageChild(box=XmCreateRowColumn(parent,"column3",NULL,0));
	XtSetArg(args[0],XmNvalue,ElitePercentage);
	XtSetArg(args[1],XmNmaximum,70);
	XtSetArg(args[2],XmNminimum,0);
	XtManageChild(scale=XmCreateScale(box,"elitePercentage",args,n));
	XtAddCallback(scale,XmNvalueChangedCallback,
		setIntParamCB,&ElitePercentage);
	XtSetArg(args[0],XmNvalue,PopulationSize);
	XtSetArg(args[1],XmNmaximum,1000);
	XtSetArg(args[2],XmNminimum,2);
	XtManageChild(scale=XmCreateScale(box,"populationSize",args,n));
	XtAddCallback(scale,XmNvalueChangedCallback,setPopSizeCB,NULL);
}
static void redrawCB(w,cl,cd) Widget w; XtPointer cl,cd;
{	redisplay(((XmDrawingAreaCallbackStruct *)cd)->event); }
main(argc,argv)
int	argc;
char	*argv[];
{
	Widget	menu_bar, command, work;
	Position	x, y;
	Dimension	width;
	Arg	args[2];

	app_sh = XtAppInitialize(&app_con,"GA",NULL,0,
		&argc,argv,fallback_resources,NULL,0);
	dpy = XtDisplay(app_sh);
	scr = DefaultScreen(dpy);
	gc = DefaultGC(dpy,scr);
	XtSetArg(args[0],XmNshowSeparator,True);
	XtManageChild(MainWindow=XmCreateMainWindow(app_sh,"main",args,1));
	XtManageChild(menu_bar=XmCreateMenuBar(MainWindow,"menu_bar",NULL,0));
	create_menus(menu_bar,buttons);
	XtManageChild(work=XmCreateDrawingArea(MainWindow,"work",NULL,0));
	XtAddCallback(work,XmNexposeCallback,redrawCB,NULL);
	XtSetArg(args[0],XmNorientation,XmHORIZONTAL);
	XtManageChild(command=XmCreateRowColumn(MainWindow,"command",args,1));
	create_command(command);
	XtVaSetValues(MainWindow,XmNcommandWindow,command,NULL);
	XtRealizeWidget(app_sh);
	init_generation_window();
	domain_init(XtWindow(work));
	monitor_init();
	reset_gui();
	XtAppMainLoop(app_con);
}