#include "gdisplay.h"
#include <sys/types.h>
#include <sys/prctl.h>
#include <stdio.h>

struct item *items;
struct trace *traces;
struct wind *winds;
struct glob *g = 0;
static int gpinit = 0;

int xo,yo;
int np;
int s0 = 0;
int *mbuf0,*mbuf1,*mbuf2,*mbuf3,*mbuf4;
static int gmn = 0;
static int gmemid[16],gmemi[16];

#define MBSIZE 1024

/* --------------------------------------------------------------------	*/
/*		Initialize multi-process environment			*/
/* --------------------------------------------------------------------	*/

init_proc()
{
	static int wfirst = 1;
	int pp;
	extern void proc1();

	if(wfirst==0)
		return;
	pp = getpid();
#ifdef SPROC
	sproc(proc1,PR_SALL,pp);
#else
	if(!fork())
		proc1(pp);
#endif
	wfirst = 0;
}

/* --------------------------------------------------------------------	*/
/*		Initialize shared memory environment			*/
/* --------------------------------------------------------------------	*/

init_shm()
{
	static int sfirst = 1;
	int i;

	if(sfirst==0)
		return;
#ifdef SPROC
	items = (struct item *)malloc(N_ITEMS*sizeof(struct item));
	traces = (struct trace *)malloc(N_TRACES*sizeof(struct trace));
	winds = (struct wind *)malloc(N_WINDS*sizeof(struct wind));
	g = (struct glob *)malloc(sizeof(struct glob));
	mbuf0 = (int *)malloc(MBSIZE*4);
	mbuf1 = (int *)malloc(MBSIZE*4);
	mbuf2 = (int *)malloc(MBSIZE*4);
	mbuf3 = (int *)malloc(MBSIZE*4);
	mbuf4 = (int *)malloc(MBSIZE*4);
#else
	s0 = shmget(IPC_PRIVATE,N_ITEMS*sizeof(struct item) +
		N_TRACES*sizeof(struct trace) + N_WINDS*sizeof(struct wind) + 
		sizeof(struct glob)+MBSIZE*4*5,0777);
	items = (struct item *)shmat(s0,0,0);
	traces = (struct trace *)(((long)items)+N_ITEMS*sizeof(struct item));
	winds = (struct wind *)(((long)traces)+N_TRACES*sizeof(struct trace));
	g = (struct glob *)(((long)winds)+N_WINDS*sizeof(struct wind));
	mbuf0 = (int *)(((long)g)+sizeof(struct glob));
	mbuf1 = (int *)(((long)mbuf0)+MBSIZE*4);
	mbuf2 = (int *)(((long)mbuf1)+MBSIZE*4);
	mbuf3 = (int *)(((long)mbuf2)+MBSIZE*4);
	mbuf4 = (int *)(((long)mbuf3)+MBSIZE*4);
#endif
	g->nwindows = 0;
	g->ni = 0;
	g->nt = 0;
	g->wpt = g->rpt = 0;
	g->oldnoise = 0;
	g->newnoise = 6;
	g->mem0 = mc_scan_plusargs("mem0");
	sfirst = 0;
}

/* --------------------------------------------------------------------	*/
/*		Set time between updates				*/
/* --------------------------------------------------------------------	*/

gupdate(a,b)
{
	g->newnoise = tf_getp(1);
}

/* --------------------------------------------------------------------	*/
/*		Write Memory Location					*/
/* --------------------------------------------------------------------	*/

gwmem(a,b)
{
	int i,x,y,val,valz,id;

	id = tf_getp(1);
	x = tf_getp(2);
	y = tf_getp(3);
	tf_getpz(4,&val,&valz);
	for(i=0;i<gmn;i++)
		if(gmemid[i]==id)
			break;
	if(i==gmn) return;
	i = gmemi[i];
	if(items[i].mem1==0)
		clear_mem1(&items[i]);
	if(items[i].mem1[y]==0)
		clear_mem1y(&items[i],y);
	while((g->wpt+1)%MBSIZE==g->rpt);
	mbuf0[g->wpt] = i;
	mbuf1[g->wpt] = x;
	mbuf2[g->wpt] = y;
	mbuf3[g->wpt] = val;
	mbuf4[g->wpt] = valz;
	g->wpt = (g->wpt+1)%MBSIZE;
	items[i].mem1[y][x]=val;
	items[i].zmem1[y][x]=valz;
}

/* --------------------------------------------------------------------	*/
/*		Read Memory Location					*/
/* --------------------------------------------------------------------	*/

grmem(a,b)
{
	int i,x,y,val,id;

	id = tf_getp(1);
	x = tf_getp(2);
	y = tf_getp(3);
	for(i=0;i<gmn;i++)
		if(gmemid[i]==id)
			break;
	if(i==gmn) return;
	i = gmemi[i];
	if(items[i].mem1==0)
		clear_mem1(&items[i]);
	if(items[i].mem1[y]==0)
		clear_mem1y(&items[i],y);
	tf_putpz(4,items[i].mem1[y][x],
		items[i].zmem1[y][x]);
}

/* --------------------------------------------------------------------	*/
/*		Initialize gdisplay window				*/
/* --------------------------------------------------------------------	*/

gdisplay_call(a,b)
int a,b;
{
	int i,n,cmd,w,j,k;
	char str[256];
	int x,y,xx;
	short p1;
	int p0;
	int tmp;
	int cc;
	int msz;
	struct t_tfexprinfo ee;
	int temp;
	int dot;

	i = 1;

	init_shm();
	strcpy(winds[g->nwindows].mipname,tf_mipname());
	winds[g->nwindows].col = tf_getp(i++);
	winds[g->nwindows].x = tf_getp(i++);
	winds[g->nwindows].y = tf_getp(i++);
	winds[g->nwindows].w = tf_getp(i++);
	winds[g->nwindows].h = tf_getp(i++);
	winds[g->nwindows].ci = tf_getinstance();
	winds[g->nwindows].oldshow = 0;
	winds[g->nwindows].tpos = 0;
	for(j=0,dot=0;winds[g->nwindows].mipname[j];j++)
		if(winds[g->nwindows].mipname[j]=='.')dot++;
	if(dot>1)
		winds[g->nwindows].newshow = 0;
	else
		winds[g->nwindows].newshow = 1;
	n = tf_nump();
	while(i<n)
	{
		items[g->ni].cmd = tf_getp(i++);
		if(tf_typep(i)!=tf_string)
			items[g->ni].col = tf_getp(i++);
		else
			items[g->ni].col = winds[g->nwindows].col;
		items[g->ni].tag = -1;
		strcpy(items[g->ni].name,tf_getp(i++));
		if(items[g->ni].cmd==0||items[g->ni].cmd==3||
		    items[g->ni].cmd==6)
			strcpy(items[g->ni].fmt,tf_getp(i++));
		items[g->ni].x0 = tf_getp(i++);
		items[g->ni].y0 = tf_getp(i++);
		items[g->ni].x1=items[g->ni].x0+tf_getp(i++);
		items[g->ni].y1=items[g->ni].y0+tf_getp(i++);
		if(items[g->ni].cmd<5)
		{
			if(items[g->ni].cmd!=2)
				items[g->ni].p = i++;
			if(items[g->ni].cmd==1||items[g->ni].cmd==2||
			    items[g->ni].cmd==3)
				items[g->ni].tag = tf_getp(i++);
			if(items[g->ni].cmd==2)
				items[g->ni].newval = items[g->ni].oldval = 
					items[g->ni].newnewval = 0;
			else
				tf_getpz(items[g->ni].p,&items[g->ni].newval,
					&items[g->ni].newzval);
			items[g->ni].oldval = items[g->ni].newval;
			items[g->ni].oldzval = items[g->ni].newzval;
			items[g->ni].tval = tf_getp(items[g->ni].p);
			tf_exprinfo(items[g->ni].p,&ee);
			items[g->ni].size = ee.expr_vec_size;
		}
		else if(items[g->ni].cmd==5)
		{
			strcpy(items[g->ni].fmt,tf_getp(i++));
			items[g->ni].newval = 0;
			items[g->ni].oldval = 0;
			items[g->ni].newzval = 0;
			items[g->ni].oldzval = 0;
			items[g->ni].tval = 0;
			items[g->ni].size = 1;
		}
		else if(items[g->ni].cmd==6)
		{
			items[g->ni].tval = 0;
			items[g->ni].size = 1;
			items[g->ni].xsize = tf_getp(i++);
			items[g->ni].ysize = tf_getp(i++);
			items[g->ni].mem = 0;
			items[g->ni].mem = 0;
			items[g->ni].zmem = 0;
			items[g->ni].mem1 = 0;
			items[g->ni].zmem1 = 0;
			items[g->ni].xpos = 0;
			items[g->ni].ypos = 0;
#ifdef OLDMEM
			items[g->ni].px = i++;
			items[g->ni].py = i++;
			items[g->ni].pwe = i++;
			items[g->ni].pwd = i++;
			items[g->ni].prd = i++;
#else
			gmemid[gmn] = tf_getp(i++);
			gmemi[gmn] = g->ni;
			gmn++;
#endif
		}
		else if(items[g->ni].cmd==7)
		{
			int pos;
			items[g->ni].tval = 0;
			items[g->ni].size = 1;
			pos = 0;
			items[g->ni].tsize = tf_getp(i++);
			items[g->ni].tmul = tf_getp(i++);
			items[g->ni].major = tf_getp(i++)*items[g->ni].tmul;
			items[g->ni].p = i++;
			items[g->ni].nt = 1;
			items[g->ni].px1 = 0;
			items[g->ni].ci = tf_getinstance();
			msz = -1;
			while(1)
			{
				if(i==n)
					break;
				if(tf_typep(i)!=tf_string)
					break;
				else if(!strcmp(tf_getp(i),""))
				{
					pos++;
					i += 3;
					items[g->ni].nt ++;
					continue;
				}
				else
					traces[g->nt].pos = pos++;
				traces[g->nt].ci = tf_getinstance();
				strcpy(traces[g->nt].name,tf_getp(i++));
				for(k=0;traces[g->nt].name[k];k++);
				if(k>msz)
				{
					msz = k;
					items[g->ni].px1 = msz*7+25;
				}
				strcpy(traces[g->nt].fmt,tf_getp(i++));
				traces[g->nt].p = i++;
				tf_getpz(traces[g->nt].p,&traces[g->nt].newval,
					&traces[g->nt].newzval);
				tf_exprinfo(traces[g->nt].p,&ee);
				traces[g->nt].size = ee.expr_vec_size;
				traces[g->nt].op[0].data = traces[g->nt].newval;
				traces[g->nt].op[0].zdata=traces[g->nt].newzval;
				traces[g->nt].op[0].time = 0;
				traces[g->nt].op[0].on=tf_getp(items[g->ni].p);
				traces[g->nt].oN = traces[g->nt].op[0].on;
				traces[g->nt].n = 1;
				traces[g->nt].in = g->ni;
				traces[g->nt].wrap = 0;
				g->nt++;
				items[g->ni].nt ++;
			}
			items[g->ni].ypos = 0;

			w = items[g->ni].x1-items[g->ni].x0;
			if(items[g->ni].tsize+items[g->ni].px1 > w-24)
				items[g->ni].xpos=items[g->ni].tsize+
					items[g->ni].px1-(w-24);
			else
				items[g->ni].xpos = 0;
		}
		items[g->ni].redraw = 1;
		items[g->ni].wn = g->nwindows;
		g->ni++;
	}
	tf_asynchon();
	g->nwindows++;
	init_proc();
	gdisplay_update(a,b);
}

/* --------------------------------------------------------------------	*/
/*		Update gdisplay window					*/
/* --------------------------------------------------------------------	*/

gdisplay_update(a,b)
int a,b;
{
	register int k;
	int n,cmd,j;
	char str[256];
	int x,y,xx,z;
	short p1;
	int p0;
	int tmp;
	int cc;
	struct t_tfexprinfo ee;
	char * ci;
	int tn;
	register struct trace *t;
	register struct item *i;
	char change[2048];

	if(g==0) return;
	for(k=tf_nump()-1;k>=0;k--)
		change[k] = 0;
	tf_movepvc_flag(-1);
	for(k=tf_getpchange(0);k;k=tf_getpchange(k))
		change[k] = 1;

	g->thetime = tf_gettime();
	ci = tf_getinstance();
	for(k=0;k<g->ni;k++)
	{
		i = &items[k];
		if(winds[i->wn].ci != ci)
			continue;
		if(!change[i->p])
			continue;
		if(i->cmd==0)
			tf_getpz(i->p,&i->newval,&i->newzval);
	}
	for(k=0;k<g->nt;k++)
	{

		t = &traces[k];
		i = &items[t->in];
		if(t->ci != ci)
			continue;
		if(!change[t->p]&&!change[i->p])
			continue;
		tf_getpz(t->p,&x,&z);
		if(t->oN && (x!=t->newval||z!=t->newzval)||
		  t->oN != tf_getp(i->p))
		{
			if(t->op[t->n-1].time==g->thetime*i->tmul)
				tn = t->n-1;
			else
				tn = t->n;
			if(tn==TSIZE)
			{
				tn = 0;
				t->wrap = 1;
			}
			t->op[tn].data = x;
			t->op[tn].zdata = z;
			t->op[tn].time = g->thetime*i->tmul;
			t->oN = tf_getp(i->p);
			t->op[tn].on = t->oN;
			t->n=tn+1;
		}
		t->newval = x;
		t->newzval = z;
	}
#ifdef __sgi__
	sginap(0);
#else
	usleep(0);
#endif
}


/* --------------------------------------------------------------------	*/
/*		Check arguments for gdisplay				*/
/* --------------------------------------------------------------------	*/

gdisplay_error(a,b)
int a,b;
{
	int i,n,cmd;
	char str[256];
	int x0,y0,x1,y1;
	int x,y;
	static int redraw;
	short p1;
	int p0;

	n = tf_nump();
	if(n<5)
	{
		tf_error("Argument count error for $gdisplay");
		return;
	}
	i = 1;
	if(is_val(tf_typep(i++)))
	{
		tf_error("Bad Argument for win_x");
		return;
	}
	if(is_val(tf_typep(i++)))
	{
		tf_error("Bad Argument for win_y");
		return;
	}
	if(is_val(tf_typep(i++)))
	{
		tf_error("Bad Argument for win_w");
		return;
	}
	if(is_val(tf_typep(i++)))
	{
		tf_error("Bad Argument for win_h");
		return;
	}
	if(tf_typep(i++)!=tf_string)
	{
		tf_error("Bad Argument for $gdisplay");
		return;
	}
	while(i<n)
	{
	    cmd = tf_getp(i);
	    if(is_val(tf_typep(i++)))
	    {
		tf_error("Bad Argument for cmd");
		return;
	    }
	    if(tf_typep(i++)!=tf_string)
	    {
		tf_error("Bad Argument for name (%d)",i);
		return;
	    }
	    if(cmd==0||cmd==3||cmd==4)
	    {
	        if(tf_typep(i++)!=tf_string)
		{
			tf_error("Bad Argument for format");
			return;
		}
	    }
	    if(cmd==1||cmd==2||cmd==3)
	    {
		if(is_val(tf_typep(i++)))
		{
			tf_error("Bad Argument for tag");
			return;
		}
	    }
	    if(cmd==0||cmd==1||cmd==2||cmd==3)
	    {
		if(is_val(tf_typep(i++)))
		{
			tf_error("Bad Argument for x");
			return;
		}
		if(is_val(tf_typep(i++)))
		{
			tf_error("Bad Argument for y");
			return;
		}
		if(is_val(tf_typep(i++)))
		{
			tf_error("Bad Argument for w");
			return;
		}
		if(is_val(tf_typep(i++)))
		{
			tf_error("Bad Argument for h");
			return;
		}
	    }
	    if(is_val(tf_typep(i++)))
	    {
			tf_error("Bad Argument for expr");
			return;
	    }
	}
}

/* --------------------------------------------------------------------	*/
/*		Return size for gget					*/
/* --------------------------------------------------------------------	*/

gget_fsize(a,b)
int a,b;
{
	int i;
	char *mn;

	mn = tf_mipname();
	for(i=0;i<g->ni;i++)
		if(!strcmp(mn,winds[items[i].wn].mipname)&&
			items[i].tag==tf_getp(1))
		{
			if(items[i].cmd==1||items[i].cmd==2||items[i].cmd==3)
				return(items[i].size);
		}
	return(0);
}

/* --------------------------------------------------------------------	*/
/*		Return value for gget					*/
/* --------------------------------------------------------------------	*/

gget(a,b)
int a,b;
{
	int i;
	int x;
	char *mn;

	mn = tf_mipname();
	x = 0;
	for(i=0;i<g->ni;i++)
		if(!strcmp(mn,winds[items[i].wn].mipname)&&
			items[i].tag==tf_getp(1))
		{
			if(items[i].cmd==1||items[i].cmd==3)
			{
				x = items[i].newval;
			}
			if(items[i].cmd==2)
			{
				x = (items[i].newnewval!=0);
				if(items[i].newnewval)
					items[i].newnewval --;
			}
				
		}
	tf_putp(0,x);
}


is_val(v)
{
	if(v!=tf_readonly&&v!=tf_readwrite)
		return(1);
	else
		return(0);
}

int get_message(a,b,c,d,e)
int *a,*b,*c,*d,*e;
{
	if(g->rpt==g->wpt)return(-1);
	*a = mbuf0[g->rpt];
	*b = mbuf1[g->rpt];
	*c = mbuf2[g->rpt];
	*d = mbuf3[g->rpt];
	*e = mbuf4[g->rpt];
	g->rpt = (g->rpt+1)%MBSIZE;
	return(0);
}

clear_mem1(i)
struct item *i;
{
        int j,k;

        i->mem1 = (int **)malloc(i->ysize*4);
        i->zmem1 = (int **)malloc(i->ysize*4);
	for(k=0;k<i->ysize;k++)
	{
		i->mem1[k] = 0;
		i->zmem1[k] = 0;
	}
}


clear_mem1y(i,y)
struct item *i;
{
        int j,k;

        i->mem1[y] = (int *)malloc(i->xsize*4);
        i->zmem1[y] = (int *)malloc(i->xsize*4);
	if(g->mem0)
		for(k=0;k<i->xsize;k++)
		{
			i->mem1[y][k]  = 0x0;
			i->zmem1[y][k] = 0x0;
		}
	else
		for(k=0;k<i->xsize;k++)
		{
			i->mem1[y][k]  = 0xffffffff;
			i->zmem1[y][k] = 0xffffffff;
		}
}