#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 "seq.h"
#include "OSCAIO.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( SFReply *replyPtr)
{
	SFTypeList		typeList;
	struct Point   	somewhere = { 20, 90 };
	
	typeList[0] = 'TEXT';
	SFGetFile(somewhere,nil,nil, 0 , typeList,nil, replyPtr);

}

/*********** OpenReadFile ***************/

FILE *OpenReadFile(SFReply *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(SFReply *reply,ConstStr255Param prompt,char *ext)
{
	char				tmpString[256];
	struct Point   		somewhere = { 20, 90 };
	FILE				*fp;
	SFReply				OutputReply;
	FInfo 				finderInfo;
	OSErr				error;
	char				mode[4];
	char				*extcheck;
	
	strcpy(tmpString,p2cstr(reply->fName));
	c2pstr((char *) reply->fName);
	strcat(tmpString,ext);
	c2pstr((char *) tmpString);
				
	SFPutFile(somewhere,(ConstStr255Param) prompt,(ConstStr255Param) tmpString,nil,&OutputReply);

	if(strcmp(".sum",ext)==0) // if summary (.sum),  open summary and not source file
	{
		memcpy(reply,&OutputReply,sizeof(OutputReply));
	}		
			

	if(OutputReply.good == 1)
	{
		SetVol(nil,OutputReply.vRefNum);
		
		extcheck = ext + strlen(ext) - 3;
		
		if(strcmp(".si",extcheck)==0)
			strcpy(mode,"wb");
		else
			strcpy(mode,"w");
				
		if ((fp = fopen(p2cstr(OutputReply.fName),mode)) == NULL)
		{
			SeqDoError("\pCan't open Write File...",true,env);
		}
		else
		{ 
			c2pstr((char *)OutputReply.fName);
			if(strcmp(".si",extcheck)==0) // if (.si),  change File type and Creator
			{
				GetFInfo((StringPtr)tmpString,0,&finderInfo);
				
				finderInfo.fdType='SiBi';
				finderInfo.fdCreator='GWN1';
				
		
				if(error=SetFInfo((StringPtr)tmpString,0,&finderInfo))
				{	
					SeqDoError("\pError while changing FinderInfo...",true,env);
					ExitToShell();
				};			
				
			}

			return fp;
		}


	}
	else 
		return NULL;

}

/*********** PrintImageFile *************/

void PrintImageFile(int macronumber,SFReply *reply)
{
	int 				i,j;
	FILE 				*saveFile;
	unsigned short		memPart;	
	
	if((saveFile = OpenSaveFile(reply,"\pSave Image file as ...",".img")) == NULL)
		return;
				
	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,SFReply *reply)
{
	int 				i,j;
	FILE 				*saveFile;	

	if((saveFile = OpenSaveFile(reply,"\pSave Hex file as ...",".hex")) == NULL)
		return;
							
	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, SFReply *reply)
{
	int 				i,j;
	char				tmpMacroName[256];
	FILE 				*saveFile;	

	if((saveFile = OpenSaveFile(reply,"\pSave Macro list as ...",".macro")) == NULL)
		return;
		
	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(SFReply *reply)
{
	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);

	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,SFReply *reply)
{
	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;

	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,SFReply *reply)
{
	SeqDoError("\pFeature not yet supported",true,env);
}