/******************************************************************************
 *
 *  Title  : dataFileCreator.c
 *  Version 0.0
 *
 *  Description: Binary file creator utility.
 *
 *
 *  Author: Lukas Tomasek, tomasekl@fzu.cz
 *
 ******************************************************************************/

#include <utility.h>
#include <ansi_c.h>
#include <cvirte.h>
#include <userint.h>
#include "dataFileCreator.h"

#define DATA_SUBDIR "\\Data\\"
#define DATA_FILE_CREATOR_SUBDIR "\\DataFileCreator\\"
#define BIN_VIEWER "\\Witched\\Witched.exe "
#define PATHNAME_LENGTH 300
typedef unsigned int UINT32;
typedef unsigned char UINT8;
typedef float FLOAT32;

static int panelHandle;
static UINT32 *tableBuffer=NULL;
static UINT8 *tableBufferByte;
static int wordSize_global=4;
static currentBufferSize=0;
static UINT32 totalBytes_global, totalWords_global;
static unsigned int slideMax=1;
static char mainDir[PATHNAME_LENGTH];
static char binViewerFileName[PATHNAME_LENGTH];
static char dataDir[PATHNAME_LENGTH];
int status;


static void refreshTable(UINT32 startAddress, int panel);

int main (int argc, char *argv[])
{
	if (InitCVIRTE (0, argv, 0) == 0)
		return -1;	/* out of memory */
	if ((panelHandle = LoadPanel (0, "dataFileCreator.uir", PANEL)) < 0)
		return -1;

	status=GetProjectDir(mainDir);
	/* remove Rcc subdirectory */
	mainDir[strlen(mainDir)-strlen(DATA_FILE_CREATOR_SUBDIR)+1]=0;
	if(status!=0){
		printf("Invalid project directory(%s)!!.", mainDir);
		printf("\nPress any key to quit.");
		getchar();
		return(-1);
	}
	/* get  file name */
	strcpy(binViewerFileName, mainDir);
    strcat(binViewerFileName, BIN_VIEWER);

	strcpy(dataDir, mainDir);
    strcat(dataDir, DATA_SUBDIR);


	DisplayPanel (panelHandle);
	RunUserInterface ();
	DiscardPanel (panelHandle);

	if(tableBuffer!=NULL){
		free(tableBuffer);
	}
	return 0;
}

int CVICALLBACK buttons (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	UINT32 dataSize;
	UINT32 value[2];
	FLOAT32 floatValue;
	FLOAT32 floatIncrement;
	UINT8 *valueByte=(UINT8*)value;
	int dataType;
	UINT32 currentAddress;
	UINT32 words;
	int index, i, j;
	int transBit;
	int columnIndex, rowIndex;
	int tableAddress;
	unsigned int var;
	int status;
	char fileName[PATHNAME_LENGTH];
	char viewFile[PATHNAME_LENGTH];
	long fileSize;
	int increment;
	int intFloat;
	UINT8 tempByte;

	FILE *fileHandle;

	if(event==EVENT_COMMIT){
		switch(control){
			case PANEL_ADD_TO_TABLE:
				GetCtrlVal(panel, PANEL_WORD_SIZE, &wordSize_global);
				GetCtrlVal(panel, PANEL_DATA_TYPE, &dataType);
				GetCtrlVal(panel, PANEL_INIT_VALUE1, &value[1]);
				GetCtrlVal(panel, PANEL_WORDS, &words);
				GetCtrlVal(panel, PANEL_CURRENT_ADDR, &currentAddress);
				GetCtrlVal(panel, PANEL_TABLE_ADDR, &tableAddress);
				GetCtrlVal(panel, PANEL_INT_FLOAT, &intFloat);
				
				if(intFloat)
				{
				GetCtrlVal(panel, PANEL_INIT_VALUE0, &value[0]);
				GetCtrlVal(panel, PANEL_INCREMENT, &increment);				
				}
				else
				{
				GetCtrlVal(panel, PANEL_INIT_VALUE0, (FLOAT32 *)&value[0]);
				GetCtrlVal(panel, PANEL_INCREMENT, (FLOAT32 *)&increment);				
				}
				
				totalBytes_global=currentAddress+4*((words*wordSize_global+3)/4);
				totalWords_global=totalBytes_global/wordSize_global;
				if(totalBytes_global==0) break;
				if(totalBytes_global>currentBufferSize){
					if(tableBuffer==NULL){
						tableBuffer=malloc(totalBytes_global);
					}
					tableBuffer=realloc(tableBuffer, totalBytes_global);
					currentBufferSize=totalBytes_global;
				}
				if(tableBuffer==NULL){
					printf("ERROR - cannot allocate memory!!");
					break;
				}

				SetCtrlAttribute (panel, PANEL_TABLE_SLIDE, ATTR_MAX_VALUE, totalBytes_global);
				SetCtrlVal(panel, PANEL_TABLE_SLIDE, slideMax);
				SetCtrlAttribute(panel, PANEL_TOTAL_WORDS, ATTR_MAX_VALUE, totalWords_global);
				SetCtrlAttribute(panel, PANEL_TABLE_ADDR, ATTR_MAX_VALUE, totalBytes_global-4);
				GetCtrlVal(panel, PANEL_TOTAL_WORDS, &var);
				if(var<totalWords_global){
					SetCtrlVal(panel, PANEL_TOTAL_WORDS, totalWords_global);
				}
				SetCtrlVal(panel, PANEL_BUFF_WORDS, totalWords_global);
				SetCtrlVal(panel, PANEL_TABLE_SLIDE, (totalBytes_global-tableAddress));

				switch(dataType){
					case 0: /* constant */
						index=currentAddress/4;
						tableBufferByte=(UINT8*)&tableBuffer[index];
						if((wordSize_global==6)&&((index%6)!=0)){
							tableBufferByte+=2;
						}
						for(i=0; i<words; ++i){
							for(j=0; j<wordSize_global; j++){
								tableBufferByte[wordSize_global*i+j]=valueByte[j];
							}
						}


						break;
					case 1: /* increment */
						index=currentAddress/4;
						tableBufferByte=(UINT8*)&tableBuffer[index];

						if(intFloat)
						{
							if((wordSize_global==6)&&((index%6)!=0)){
								tableBufferByte+=2;
							}
							for(i=0; i<words; ++i){
								for(j=0, transBit=0; j<wordSize_global; j++){
									if(i>0){
										valueByte[j]+=transBit;
										if((valueByte[j])>(0xFF-increment)){
											valueByte[j]=0;
											transBit=1;
										}else{
											if(j==0){
												valueByte[0]+=increment;
											}
											transBit=0;
										}
									}
									tableBufferByte[wordSize_global*i+j]=valueByte[j];
								}
							}
						}
						else //float
						{
							GetCtrlVal(panel, PANEL_INIT_VALUE0, &floatValue);
							GetCtrlVal(panel, PANEL_INCREMENT, &floatIncrement);

							valueByte = (UINT8 *) &floatValue;

							for(i=0; i<words; ++i){
								for(j=0; j<wordSize_global; j++){
									tableBufferByte[wordSize_global*i+j]=valueByte[j];
								}
								floatValue += floatIncrement;
							}
						}

						break;
					case 2: /* left shift */
						index=currentAddress/4;
						tableBufferByte=(UINT8*)&tableBuffer[index];
						if((wordSize_global==6)&&((index%6)!=0)){
							tableBufferByte+=2;
						}
						for(i=0, transBit=0; i<words; ++i){
							for(j=0; j<wordSize_global; j++){
								if(j==0) valueByte[j]+=transBit;
								tableBufferByte[wordSize_global*i+j]=valueByte[j];
								tempByte=valueByte[j];
								valueByte[j]<<=1;
								if(j>0) valueByte[j]+=transBit;
								if(tempByte>=0x80){
									transBit=1;
								}else{
									transBit=0;
								}

							}
						}

						break;
					case 3: /* random */
						srand((unsigned int)time(NULL));
						index=currentAddress/4;
						tableBufferByte=(UINT8*)&tableBuffer[index];
						if((wordSize_global==6)&&((index%6)!=0)){
							tableBufferByte+=2;
						}
						for(i=0; i<words; ++i){
							for(j=0; j<wordSize_global; j++){
								tableBufferByte[wordSize_global*i+j]=rand()&0xFF;
							}
						}

						break;
				}

				/* fill table */
				refreshTable(tableAddress, panel);

				break;
			case PANEL_SAVE_TO_FILE:
				GetCtrlVal(panel, PANEL_TOTAL_WORDS, &totalWords_global);
				if(totalWords_global==0) break;

				status = FileSelectPopup (dataDir, "*.bin", "*.bin","Save read table to file", VAL_SAVE_BUTTON, 0, 0, 1, 0,fileName);
				switch(status){
					case 0: /* no file selected */
						break;
					case 1: /* existing file selected */
						/* no break here */
					case 2: /* new file selected */
						fileHandle = fopen (fileName, "wb"); /* open/create binary file for write */
						if(fileHandle==NULL){
							break;
						}
						fwrite(tableBuffer, sizeof(char), totalWords_global*wordSize_global, fileHandle);
						status=fclose(fileHandle);
						break;
					default: break;
				}

				break;

			case PANEL_LOAD_FILE:

				GetCtrlVal(panel, PANEL_WORD_SIZE, &wordSize_global);
				GetCtrlVal(panel, PANEL_CURRENT_ADDR, &currentAddress);
				GetCtrlVal(panel, PANEL_TABLE_ADDR, &tableAddress);

				status=FileSelectPopup(dataDir, "*.bin","*.bin","Pick file", VAL_SELECT_BUTTON,0,0,1,1,fileName);
				if(status==VAL_NO_FILE_SELECTED){
					break;
				}
				status=GetFileSize (fileName, &fileSize);
				if(status!=0) break;

				words=fileSize/wordSize_global;
				var=currentAddress+4*((words*wordSize_global+3)/4);
				if(var>totalBytes_global){
					  totalBytes_global=var;
				}
				totalWords_global=totalBytes_global/wordSize_global;
				if(totalBytes_global==0) break;
				if(totalBytes_global>currentBufferSize){
					if(tableBuffer==NULL){
						tableBuffer=malloc(totalBytes_global);
					}
					tableBuffer=realloc(tableBuffer, totalBytes_global);
					currentBufferSize=totalBytes_global;
				}
				if(tableBuffer==NULL){
					printf("ERROR - cannot allocate memory!!");
					break;
				}

				SetCtrlAttribute (panel, PANEL_TABLE_SLIDE, ATTR_MAX_VALUE, totalBytes_global);
				SetCtrlVal(panel, PANEL_TABLE_SLIDE, slideMax);
				SetCtrlAttribute(panel, PANEL_TOTAL_WORDS, ATTR_MAX_VALUE, totalWords_global);
				SetCtrlAttribute(panel, PANEL_TABLE_ADDR, ATTR_MAX_VALUE, totalBytes_global-4);
				GetCtrlVal(panel, PANEL_TOTAL_WORDS, &var);
				if(var<totalWords_global){
					SetCtrlVal(panel, PANEL_TOTAL_WORDS, totalWords_global);
				}
				SetCtrlVal(panel, PANEL_BUFF_WORDS, totalWords_global);
				SetCtrlVal(panel, PANEL_TABLE_SLIDE, (totalBytes_global-tableAddress));

				fileHandle = fopen (fileName, "rb"); /* open binary file for read */
				if(fileHandle==NULL){
					break;
				}
				fread(&tableBuffer[currentAddress/4], sizeof(char), words*wordSize_global, fileHandle);
				status=fclose(fileHandle);

				/* fill table */
				refreshTable(tableAddress, panel);

				break;
			case PANEL_VIEW_FILE:

				strcpy(fileName, dataDir);
				strcat(fileName, "Temporary\\fileCreat.tmp");

				fileHandle = fopen (fileName, "wb"); /* open/create binary file for write */
				if(fileHandle==NULL){
					break;
				}
				fwrite(tableBuffer, sizeof(char), totalBytes_global, fileHandle);
				status=fclose(fileHandle);

				strcpy(viewFile, binViewerFileName);
				strcat(viewFile, fileName);
				status = LaunchExecutable(viewFile);
				break;
		}
	}

	return 0;
}

int CVICALLBACK table (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	Point point;
	UINT32 tableAddress;
	UINT32 currentAddress;
	UINT32 value;
	int dataIndex;
	int rowIndex,columnIndex, dimmed;
	int status;
	int wordSize;
	UINT32 currentWord;

	if(event==EVENT_VAL_CHANGED){
		switch(control){
			case PANEL_TABLE:
				GetCtrlVal(panel, PANEL_TABLE_ADDR, &tableAddress);
				dataIndex=(int)(tableAddress)/4;

				for(rowIndex=1; rowIndex<=16;++rowIndex){

					for(columnIndex=2; columnIndex<=5; ++columnIndex, ++dataIndex){
						if(dataIndex<0) continue;
						status = GetTableCellAttribute (panel, control, MakePoint(columnIndex, rowIndex), ATTR_CELL_DIMMED, &dimmed);
						if(dimmed) {
							break;
						}
						status = GetTableCellVal (panel, control, MakePoint(columnIndex, rowIndex), (UINT32*)(tableBuffer+dataIndex));
					}
				}


				break;

		}
	}
	if(((event==EVENT_VAL_CHANGED)||(event==EVENT_LEFT_CLICK)||(event==EVENT_LEFT_DOUBLE_CLICK))&&(control==PANEL_TABLE)){

		GetCtrlVal (panel, PANEL_TABLE_ADDR, &tableAddress);
		GetActiveTableCell (panel, control, &point);

		currentAddress=tableAddress+(point.x-2)*4+(point.y-1)*0x10;
		GetCtrlVal(panel, PANEL_WORD_SIZE, &wordSize);

		currentAddress=((currentAddress+wordSize_global-1)/wordSize_global)*wordSize_global;
		currentWord=currentAddress/wordSize_global;
		SetCtrlVal(panel, PANEL_CURRENT_ADDR, currentAddress);
		SetCtrlVal(panel, PANEL_CURRENT_WORD, currentWord);

	}
	return 0;
}


int CVICALLBACK newValue (int panel, int control, int event,
		void *callbackData, int eventData1, int eventData2)
{
	int wordSize;
	UINT32 tableAddress, newAddr, lastAddress, var;
	unsigned int slideValue;
	int rowIndex, columnIndex;
	int dataType;
	int option;
	int intFloat;
	int count;


	if(event==EVENT_VAL_CHANGED){
		switch(control){

		    case PANEL_HEX_NOT_DEC:
		    	GetCtrlVal(panel, control, &option);
		    	if(option){
					SetCtrlAttribute (panel, PANEL_WORDS, ATTR_FORMAT, VAL_HEX_FORMAT);
					SetCtrlAttribute (panel, PANEL_TOTAL_WORDS, ATTR_FORMAT, VAL_HEX_FORMAT);
				}else{
					SetCtrlAttribute (panel, PANEL_WORDS, ATTR_FORMAT, VAL_DECIMAL_FORMAT);
					SetCtrlAttribute (panel, PANEL_TOTAL_WORDS, ATTR_FORMAT, VAL_DECIMAL_FORMAT);
				}

		    	break;
			case PANEL_WORD_SIZE:
				GetCtrlVal(panel, control, &wordSize);
				SetInputMode(panel, PANEL_INIT_VALUE1, (wordSize>4));
				break;
			case PANEL_DATA_TYPE:
				GetCtrlVal(panel, control, &dataType);
				SetInputMode(panel, PANEL_INCREMENT, (dataType==1));
				break;

			case PANEL_TABLE_ADDR:
				GetCtrlVal(panel, control, &newAddr);
				tableAddress=newAddr&0xFFFFFFF0;
				SetCtrlVal(panel, control, tableAddress);

				slideValue=(totalBytes_global-tableAddress);
				SetCtrlVal(panel, PANEL_TABLE_SLIDE, slideValue);

				/* no break */
			case PANEL_TABLE_SLIDE:
			   	if(tableBuffer==NULL){
					break;
				}

				if(control==PANEL_TABLE_SLIDE){
					GetCtrlVal(panel, control, &slideValue);
					tableAddress=(totalBytes_global-slideValue)&0xFFFFFFF0;
					if(tableAddress>=(totalBytes_global)) {
						tableAddress=(tableAddress-0x10)&0xFFFFFFF0;
					}
					SetCtrlVal(panel, PANEL_TABLE_ADDR, tableAddress);
				}

				/* fill table */
				refreshTable(tableAddress, panel);

				if(control==PANEL_TABLE_ADDR){
					SetActiveCtrl (panel, PANEL_TABLE);
					SetActiveTableCell(panel, PANEL_TABLE, MakePoint((newAddr-tableAddress)/4+2,1));
				}

				break;

			case PANEL_TOTAL_WORDS:
				GetCtrlVal(panel, PANEL_TOTAL_WORDS, &totalWords_global);
				totalBytes_global= totalWords_global*wordSize_global;
				var=totalWords_global*wordSize_global;
				if(var>256){
					var-=256;
				}else{
					var=0;
				}

				tableAddress=var&0xFFFFFFF0;
				SetCtrlVal(panel, PANEL_TABLE_ADDR, tableAddress);

				slideValue=(totalBytes_global-tableAddress);
				SetCtrlVal(panel, PANEL_TABLE_SLIDE, slideValue);

			   	if(tableBuffer==NULL){
					break;
				}
				/* fill table */
				refreshTable(tableAddress, panel);

				break;

			case PANEL_INT_FLOAT:
				GetCtrlVal(panel, control, &intFloat);

				SetCtrlAttribute(panel, PANEL_INIT_VALUE0, ATTR_DATA_TYPE, intFloat ? VAL_UNSIGNED_INTEGER : VAL_FLOAT );
				SetCtrlAttribute(panel, PANEL_INCREMENT, ATTR_DATA_TYPE, intFloat ? VAL_INTEGER : VAL_FLOAT );
				SetCtrlVal(panel, PANEL_WORD_SIZE, 4);	//set word length to 4 bytes
				SetInputMode(panel, PANEL_WORD_SIZE, intFloat);
				SetInputMode(panel, PANEL_INIT_VALUE1, 0);  // if integer then anyway WORD_SIZE==4 => INIT_VALUE1 = DIMMED;
				
				if(intFloat)
				{
					GetNumListItems (panel, PANEL_DATA_TYPE, &count);
					if (count == 2) 
					{
						InsertListItem (panel, PANEL_DATA_TYPE, 2, "LEFT SHIFT", 2);
						InsertListItem (panel, PANEL_DATA_TYPE, 3, "RANDOM", 3);	
					}
				}
				else
				{
					SetCtrlVal (panel, PANEL_DATA_TYPE, 0); // CONSTANT
					SetInputMode(panel, PANEL_INCREMENT, 0);
					
					GetNumListItems (panel, PANEL_DATA_TYPE, &count);
					if (count == 4) DeleteListItem (panel, PANEL_DATA_TYPE, 2, 2);
				}


				break;

		}

	}
	return 0;
}

void CVICALLBACK menu (int menuBar, int menuItem, void *callbackData,
		int panel)
{
	QuitUserInterface (0);
}


static void refreshTable(UINT32 startAddress, int panel){

	int rowIndex, columnIndex;

	/* fill table */
	for(rowIndex=1; rowIndex<=16;++rowIndex){

		/* fill address */
		SetTableCellVal (panel, PANEL_TABLE, MakePoint(1, rowIndex), startAddress);

		for(columnIndex=2; columnIndex<=5; ++columnIndex, startAddress+=0x4){
			if(startAddress<totalBytes_global){
				SetTableCellAttribute (panel, PANEL_TABLE, MakePoint(columnIndex, rowIndex), ATTR_CELL_DIMMED, 0);
				SetTableCellVal (panel, PANEL_TABLE, MakePoint(columnIndex, rowIndex), tableBuffer[startAddress/4]);
			} else {
				SetTableCellAttribute (panel, PANEL_TABLE, MakePoint(columnIndex, rowIndex), ATTR_CELL_DIMMED, 1);
			}
		}
	}
	return;
}