#include "newoscaio.h"
#include <stdio.h>
#include <string.h>
#include <ctype.h>
/* #include <StandardFile.h> */
#include <setjmp.h>
#include <stdlib.h>
#include <math.h>
/* #include <Files.h> */
/* #include <Types.h> */
#include "newseq.h"
					
extern Seq					(*seqBuf)[2];
extern multipleSequence 	(*multSeq)[2];
extern FILE 				*fp;
extern jmp_buf				env;
extern unsigned short 		programPtr[2];
typedef char macroname_typ[256];
extern macroname_typ		*macroname;
extern int 					*macrosize;
extern unsigned short 		*macrovalue;
extern unsigned int			seqCounter[2];
extern unsigned short		SQLM_used;
extern unsigned short		SQHM_used;
extern unsigned short		memPart;


/* /********** GetFileName ***********************/

/* void 	GetFileName( char *namePtr)
{
	SFTypeList		typeList;
	struct Point   	somewhere = { 20, 90 };
	
	typeList[0] = 'TEXT';
	SFGetFile(somewhere,nil,nil, 0 , typeList,nil, replyPtr);

}
 */
/*********** OpenReadFile ***************/

/* FILE *OpenReadFile(FILE *reply)
{
	FILE				*readFile;

	GetFileName(reply);
	
	if(reply->good == 1)
	{	
		SetVol(nil,reply->vRefNum);
		if ((readFile = fopen(p2cstr(reply->fName),"r")) == NULL)	
		{
			SeqDoError("\pCan't open Read File...",true, env);
		}
		
		c2pstr((char *) reply->fName);
		
		return readFile;
	}
	else
		return NULL;
	
}
 */

/*********** OpenSaveFile ***************/

/* FILE *OpenSaveFile(char *name,char *ext)
{
	char				tmpString[256];
	char				filename[256];
	struct Point   		somewhere = { 20, 90 };
	FILE				*fp;
	SFReply				OutputReply;
	FInfo 				finderInfo;
	OSErr				error;
	char				mode[4];
	char				*extcheck;
	
        size_t len;
			
	extcheck = ext + strlen(ext) - 3;
	
	if(strcmp(".si",extcheck)==0)
		strcpy(mode,"wb");
	else
		strcpy(mode,"w");
                
        strncpy (filename, name, 255);
        filename[255] = '\0';
        len =  strlen (filename);   
        strncat (filename, ext, 255-len);
			
	if ((fp = fopen(filename,mode)) == 0)
	{
		SeqDoError("\pCan't open Write File...",true,env);
	}
        
	return fp;

}
 */
/*********** PrintImageFile *************/

void PrintImageFile(int macronumber,char *name)
{
	int 				i,j;
	FILE 				*saveFile;
	unsigned short		memPart;	
	
/* 	if((saveFile = OpenSaveFile(reply,"\pSave Image file as ...",".img")) == NULL)
		return;
 */		
        saveFile = stdout;
        		
	for(memPart=0; memPart<2; memPart++)
		for(i=0; i<programPtr[memPart]; i++)
		{
//Seq							(*seqBuf)[2];
//multipleSequence 			    (*multSeq)[2];
			fprintf(saveFile,"%4d  ",memPart);
			fprintf(saveFile,"%4d  ",(seqBuf[memPart]+i)->seqAddress);
			fprintf(saveFile,"%4d  ",(seqBuf[memPart]+i)->seqPointer);
			for(j=15;j>=0;j--)
			{		
				fprintf(saveFile,"%d", GetBit((seqBuf[memPart]+i)->seqValue,j));
				if(!(j % 4 ))
					fprintf(saveFile," ");
			}
			fprintf(saveFile,"\n");
		}
		
	fclose(saveFile);

}

/*********** PrintHexFile *************/

void PrintHexFile(int macronumber,char *name)
{
	int 				i,j;
	FILE 				*saveFile;	

/* 	if((saveFile = OpenSaveFile(reply,"\pSave Hex file as ...",".hex")) == NULL)
		return;
 */				
        saveFile = stdout;		
	for(memPart=0; memPart<2; memPart++)
		for(i=0; i<programPtr[memPart]; i++)
		{
			fprintf(saveFile,"%04x  ",(seqBuf[memPart]+i)->seqAddress);
			fprintf(saveFile,"%04x  ",(seqBuf[memPart]+i)->seqPointer);
			fprintf(saveFile,"%04x  ",(seqBuf[memPart]+i)->seqValue);
			fprintf(saveFile,"\n");
		}
	
	fclose(saveFile);

}

/************ PrintMACROListing **********/

void PrintMACROListing(int macronumber, char *name)
{
	int 				i,j;
	char				tmpMacroName[256];
	FILE 				*saveFile;	

/* 	if((saveFile = OpenSaveFile(reply,"\pSave Macro list as ...",".macro")) == NULL)
		return;
 */	
        saveFile = stdout;
        	
	fprintf(saveFile,"User defined macros : \n \n");
	fprintf(saveFile,"MacroName                      MacroSize               MacroValue \n\n");

	for(i=1;i<macronumber;i++)
	{	
		if(!strcmp(tmpMacroName, macroname[i]))
		{
			fprintf(saveFile,"                           ");
			fprintf(saveFile,"                              $%04x\t\n", macrovalue[i] );
		}
		else
		{
			fprintf(saveFile,"%-25s        %3d   ",macroname[i],macrosize[i]);
			fprintf(saveFile,"                  $%04x\t\n", macrovalue[i] );

			strcpy(tmpMacroName,macroname[i]);
		}
	}
	
	fclose(saveFile);

}
/*********** WriteSeqFile *************/

void WriteSeqFile(char *name)
{
	int 				jj;
	FILE 				*saveFileLM,*saveFileHM;		
	unsigned short      k=0;
	unsigned short		*tempBuf;
		
/* 	if(SQLM_used)
		if((saveFileLM = OpenSaveFile(reply,"\pSave Sequencer file as ...",".SQLM.si")) == NULL)
			SeqDoError("\pCan't open Write File...",false,env);
	
	if(SQHM_used)
		if((saveFileHM = OpenSaveFile(reply,"\pSave Sequencer file as ...",".SQHM.si")) == NULL)
			SeqDoError("\pCan't open Write File...",false,env);
 */
        saveFileLM = stdout;
        saveFileHM = stdout;
        
	tempBuf = (unsigned short *) calloc(32768 , 4*sizeof(unsigned short));
	
	if(tempBuf)
	{
		for(memPart=0; memPart<2; memPart++)
		{		
			for(k=0; k<programPtr[memPart]; k++)
			{
				tempBuf[2*seqBuf[memPart][k].seqAddress  ] = seqBuf[memPart][k].seqPointer;
				tempBuf[2*seqBuf[memPart][k].seqAddress+1] = seqBuf[memPart][k].seqValue;
				if(tempBuf[2*seqBuf[memPart][1].seqAddress  ]>32000)
					jj=0;
			}	
		
			if(!memPart)
			{
				if(SQLM_used)			
					fwrite(tempBuf,2 * 65536 * sizeof (unsigned short),(size_t)1,saveFileLM);
			}
			else
			{
				if(SQHM_used)			
					fwrite(tempBuf,2 * 65536 * sizeof (unsigned short),(size_t)1,saveFileHM);
			}
		}	
			
		free(tempBuf);
	}
	else
		SeqDoError("\pCan't allocate memory...",false,env);

	if(SQLM_used)
		fclose(saveFileLM);
	if(SQHM_used)
		fclose(saveFileHM);
	
}
/*********** WriteSummaryFile *************/

void WriteSummaryFile(int macronumber,char *name)
{
	int 				j;
	long   			    i;
	long	 			memSum[2];
	long 				length;
	long	 			memTotal=0;
	FILE 				*saveFile;
	char				memString[5];	

/* 	if((saveFile = OpenSaveFile(reply,"\pSave Summary file as ...",".sum")) == NULL)
		return;
 */
        saveFile = stdout;
 
	fprintf(saveFile,"*****************************************************************\n");
	fprintf(saveFile,"*****************************************************************\n");
	fprintf(saveFile,"**                                                             **\n");
	fprintf(saveFile,"**                       S U M M A R Y                         **\n");
	fprintf(saveFile,"**                                                             **\n");
	fprintf(saveFile,"*****************************************************************\n");
	fprintf(saveFile,"*****************************************************************\n");
	fprintf(saveFile,"\n\n\n");
	fprintf(saveFile,"- no errors during compilation !\n\n");
	fprintf(saveFile,"- %d Routine(s) !\n\n",seqCounter[0]+seqCounter[1]);
	
	fprintf(saveFile,"Name              StartAdd  Start    End    Length   Memory\n");
	fprintf(saveFile,"-------------------------------------------------------------\n");
	
	for(memPart=0; memPart<2; memPart++)
	{
		if(!memPart)
			strcpy(memString,"SQLM");
		else
			strcpy(memString,"SQHM");
		
		memSum[memPart]=0;
		for(i=0;i<seqCounter[memPart];i++)
		{
			fprintf(saveFile,"%-15s     $%04x   $%04x   $%04x    $%04x    %s\n",
			multSeq[memPart][i].name,
			multSeq[memPart][i].ROUTINE,
			multSeq[memPart][i].start,
			multSeq[memPart][i].end,
			multSeq[memPart][i].end-multSeq[memPart][i].start+1,memString);
			
			length=(multSeq[memPart][i].end-multSeq[memPart][i].start+1);
	
			memSum[memPart]+=length;			
	
		}
	}
	
	memTotal= memSum[0]+memSum[1];	
	fprintf(saveFile,"\n\n- Total sequencer space used :$%05lx \n\n",memTotal);
	fprintf(saveFile,"( %3.1f %% of Low Sequencer Memory (64k))\n",(float)memSum[0]/((float)(65536))*100.);
	fprintf(saveFile,"( %3.1f %% of High Sequencer Memory (64k))\n\n",(float)memSum[1]/((float)(65536))*100.);
	
				
	fclose(saveFile);
		
}


/*********** PrintAPCImageFile *************/

void PrintAPCImageFile(int macronumber,char *name)
{
	SeqDoError("\pFeature not yet supported",true,env);
}