#include <stdio.h>			/* module logs9b */
#include <conio.h>
#include <graph.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <dos.h>
#include <fcntl.h>
#include <sys\types.h>
#include <sys\stat.h>
#include <io.h>
#include <gxlib.h>
#include <txlib.h>
#include <constant.h>
#include <declare9.h>


/*****************************************************************************/
getlog(void)		/* log no. 1 oldest log at beginning of file */

{
	int fail=0;

	long offset;

		offset=((long)nb+80L)*(long)(logno-1);	/* find desired log offset */

	if(fail=!(stream=fopen("logs.723","rb")))	/* open file */
		{
		warn("COULD NOT OPEN LOGS.723");
		goto abort;
		}

	if(fail=fseek(stream,offset,SEEK_SET))		/* move pointer to offset from beginning of file */
		{
		warn("COULD NOT MOVE LOGS.723 POINTER");
		goto abort;
		}

	if(fail=load(tyme,8))
		{
		warn("UNABLE TO READ LOGGED TIME");
		goto leave;
		}

	if(fail=load(dayt,8))
		{
		warn("UNABLE TO READ LOGGED DATE");
		goto leave;
		}

	if(fail=uload(status,nb))
		{
		warn("UNABLE TO READ LOGGED STATUS");
		goto leave;
		}

	if(fail=iload(avmet,32))
		{
		warn("UNABLE TO READ LOGGED METERING");
		goto leave;
		}

leave:		fclose(stream);

abort:		return(fail);

}


/*****************************************************************************/
getblock(n,block)		/* log no. 1 oldest log at beginning of file */

/* n = first log in block, block = total logs */

{
	int fail;

	long offset;

		offset=((long)nb+80L)*(long)(n-1);	/* find desired log offset */

	if(fail=!(stream=fopen("logs.723","rb")))	/* open file */
		{
		warn("could not open LOGS.723");
		goto abort;
		}

	if(fail=fseek(stream,offset,SEEK_SET))		/* move pointer to offset from beginning of file */
		{
		warn("COULD NOT MOVE LOGS.723 POINTER");
		goto abort;
		}

	if(fail=uload(utemp,(nb+80)*block))
		warn("UNABLE TO READ LOGS");

		fclose(stream);

abort:		return(fail);

}


/*****************************************************************************/
storelog(void)				/* store a log */

{
	int i,fail;

	if(fail=(inlog()||inhist()))
		goto abort;

	if(fail=status[35]&0x80)
		goto abort;			/* simulation mode */

	if(counter[0]<counter[23])		/* less than log limit? */
		{
		status[36]&=0xFE;		/* clear logs full bit */
		++counter[0];			/* increment number of logs */
		}
	else
		{
		fail=status[36]|=0x01;		/* set logs full bit */
		text(YELLOW,200,15,"LOGS FULL");
		goto abort;
		}

	if((counter[23]-counter[0])<10)
		status[38]|=0x10;		/* logs almost full */
	else
		status[38]&=0xEF;		/* clear almost full bit */

		savemisc();			/* save log total */

		stream=fopen("logs.723","ab");	/* open file */

	if(fail=fseek(stream,0,SEEK_END))	/* move pointer to end */
		{
		warn("COULD NOT MOVE LOGS.723 POINTER");
		goto abort;
		}
	for(i=0;i<=31;i++)
		logavg[i]=avmet[i];
		save(tyme,8);			/* store new log */

		save(dayt,8);

		usave(status,nb);

		isave(avmet,32);

		fclose(stream);

	if(counter[54])				/* announce log */
		activity(1,0);

abort:  if(status[35]&0x10)
		status[35]&=0xEF;		/* clear boot store flag */

	if(status[35]&0x40)
		status[35]&=0xBF;		/* clear manual store flag */

	if(status[35]&0x20)
		status[35]&=0xDF;		/* clear clock store flag */

	if(status[36]&0x40)
		status[36]&=0xBF;		/* clear time change flag */

	if(status[36]&0x80)
		status[36]&=0x7F;		/* clear date change flag */

		counter[45]=0;

		return(fail);

}


	unsigned char bit1,bit2;

	int next;

/*****************************************************************************/
activity(flag,pact)				/* logging activity */

{
	char string[40],string1[80],bytn[8],bitn[2],signm[25],stnm[15];

	char *spacer="     ";

	int j,k,line,pflag,color,index,x,y=420,tempno,fail;

		tempno=logno;

		backdata();			/* save current database */

		clear();

		font(1);

		text(PALEBLUE,120,479,"LOGGING  ACTIVITY");

		txnumber();

		stamp();

	if(parse[4]!=CR)
		{
		if(flag&&!pact)
			logno=counter[0]-1;
		else
			{
			if(arg(1,counter[0]))	/* log number too high */
				goto abort;
			logno=atoi(&parse[4]);
			}
		}
	else
		logno=1;			/* oldest log is default value */

		font(2);

		text(WHITE,0,440,"LOG");
		tex(80,440,"METHOD");
		tex(160,440,"TIME");
		tex(240,440,"DATE");
		tex(300,440,"BYTE");
		tex(380,440,"BIT");
		tex(420,440,"CHANGE");

		clkey();

		font(3);

	if(fail=getlog())			/* get older log */
		goto abort;

	pflag=1;

loop2:  rect(BLACK,0,420,639,0);		/* clear data area */

		line=0;

		pflag^=1;
loop3:  if(logno==counter[0])
		{
		text(YELLOW,0,y-20,"END OF LOGS");
		goto await;
		}

	for(j=0;j<nb;j++)
		temp1[j]=status[j];		/* save older log */

		++logno;

	if(fail=getlog())			/* get younger log */
		goto abort;

		index=-1;

loop4:  y=420-20*line;

		texcolor(WHITE);

		number(5,y,logno,0);		/* sequence no. */

		strcpy(string1,"\n       log no. ");

		strcat(string1,itoa(logno,numb,10));

		strcat(string1,spacer);

		texcolor(PALEBLUE);

		strcpy(string,"STATUS");

		color=PALEBLUE;

	if(status[35]&0x20)
		{
		color=YELLOW;			/* stored by clock */
		strcpy(string,"CLOCK");
		}

	if(status[35]&0x40)
		{
		color=GREY;			/* manual storage */
		strcpy(string,"MANUAL");
		}

	if(status[35]&0x10)
		{
		color=RED;			/* boot storage */
		strcpy(string,"BOOT");
		}

		text(color,80,y,string);	/* method */

		strcat(string1,string);

		strcat(string1,spacer);

		text(PALEBLUE,160,y,tyme);	/* time */

		strcat(string1,tyme);

		strcat(string1,spacer);

		tex(240,y,dayt);		/* date */

		strcat(string1,dayt);

		strcat(string1,"\r\n");

	if((flag&&counter[11])||pact)
		{
		if(status[46]&0x80)
			warn("PRINTER OUT OF PAPER");
		else
			fprintf(stdprn,string1);
		}

loop:		y=420-20*line;

		++line;

		next=index+1;

		index=compare(status,temp1);		/* compare nb bytes */

	if((index==nb*8)&&next)				/* no more changes */
			goto loop3;			/* get next log */

		strcpy(string,itoa(index/8,numb,10));	/* byte number */

		text(PALEBLUE,300,y,string);

		strcpy(bytn,string);

		strcpy(string,itoa(index%8,numb,10));	/* bit number */

		strcpy(bitn,string);

		text(PALEBLUE,380,y,string);

		strcpy(string,bitlist[index]);		/* signal name */

		tex(420,y,string);

		strcpy(signm,string);

		x=425+txStrWidth(string);

	if(bit2)					/* signal state */
		{
		color=WHITE;
		strcpy(string,lolist[index]);		/* false */
		}
	else
		{
		color=LIGHTGREEN;
		strcpy(string,hilist[index]);		/* true */
		}

		text(color,x,y,string);			/* display change */

		strcpy(stnm,string);

	if((flag&&counter[11])||pact)
		fprintf(stdprn,"%17s %4s %26s %17s\r\n",
			bytn,bitn,signm,stnm);		/* send to printer */

	if(line>17)
		goto await;				/* page full */

	if(index>=nb*8-1)
		goto loop3;				/* get next log */
	else
		goto loop;				/* next change */

await:  if(flag&&!pact)					/* (RS) */
		{
		pause(2);
		goto abort;
		}

	if(pact&&pflag)
		fprintf(stdprn,"\f");

	k=caps();

	if(k==PUP)
		{
		logno=logno-40;
		if(logno<1)
			logno=1;
		if(fail=getlog())
			goto abort;
		goto loop2;
		}

	if(k!=PDN)
		goto rupt;

	if(logno!=counter[0])
		{
		if(index==nb*8)			/* last change for this log */
			goto loop2;		/* display another 20 lines */
		else
			{
			rect(BLACK,0,420,639,0);/* clear data area */
			line=0;
			goto loop4;		/* finish current log */
			}
		}

		k=0;

rupt:   keyboard[0]=k;

	if(pact&&(!pflag))
		fprintf(stdprn,"\f");

	if(k<128)
		prompt(keyboard);

abort:		logno=tempno;			/* recover original log no. */

		restdata();			/* recover original status */

	if(logno)
		fail=getlog();			/* recover original log */

		refresh=1;

		return(fail);

}
/*****************************************************************************/
compare(buf1,buf2)			/* compare n bytes bit by bit */

	unsigned char *buf1,*buf2;

{
	unsigned char mask;

	int i,j,index,shift;

		shift=next;

	for(i=shift/8;i<nb;i++)			/* byte counter */
		{
		mask=1<<(shift%8);
		for(j=shift%8;j<=7;j++)		/* compare bits */
			{
			bit1=buf1[i]&mask;	/* current log */
			bit2=buf2[i]&mask;	/* younger log */
			if(bit1!=bit2)
				goto found;
			mask=mask<<1;
			}
		shift=0;
		}

found:		index=8*i+j;			/* bitlist sequence */

	if(index>nb*8)
		index=nb*8;			/* no change */

		return(index);

}


/****************************************************************************/
backdata(void)			/* save real-time status */

{
	int i;

	for(i=0;i<nb;i++)
		temp2[i]=status[i];

}


/****************************************************************************/
restdata(void)			/* restore real-time status */

{
	int i;

	for(i=0;i<nb;i++)
		{
		status[i]=temp2[i];
		statup[i]=temp2[i];
		}

		counter[45]=0;

}

		
/*****************************************************************************/
logs(void)				/* read logs */

/*
	each log is structured as 8 bytes of ascii time of day,
	followed by 8 bytes of ascii date,
	followed by nb binary status bytes,
	followed by 64 metering bytes (32 integers),
	for a total of nb+80 bytes.
	return to real-time mode with Esc key in main program loop
*/

{
	char string[40];

	int fail,i;

	if(parse[4]!=CR)			/* argument? */
		{
		for(i=0;parse[i+4]!=CR;i++)
			numb[i]=parse[i+4];

		numb[i]=0;
		logno=atoi(numb);
		}

	else
		logno=1;

		histno=0;

		status[35]&=0x7F;		/* exit simulation mode */

		clkey();

		if((counter[0]+1)<=logno)
			{
			brief("NOT STORED");
			logno=0;
			goto abort;
			}

		backdata();			 /* save real-time status */

	if(fail=getlog())
		{
		logno=0;
		goto abort;
		}

		strcpy(string,"(LOG NUMBER ");
		strcat(string,itoa(logno,numb,10));
		strcat(string," OF ");
		strcat(string,itoa(counter[0],numb,10));
		strcat(string,")");

		font(2);

		boxit2("NEXT Esc RETURNS TO REAL-TIME",string);

		pause(3);

abort:		refresh=1;

		return(fail);

}