#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

#include "camlib.h"

// CAMAC function
#define READ 0
#define LAM 8
#define CLR 9
#define WRITE 16

// Relay MUX. channel
#define CURRENT_UP 10	// relay circuit1 off
#define CURRENT_DOWN 15	// relay circuit1 on : channel where LEMO cable is inserted
#define RESISTANCE_ON 15	// relay circuit2 on : channel where LEMO cable is inserted
#define RESISTANCE_OFF 10	// relay circuit2 off

// mimimum and maximum of ADC channel (for check of invalid input)
#define ADC_CHANNEL_MIN 0
#define ADC_CHANNEL_MAX 15

// constants about time (all measured by seconds)
#define TIME_CORRECTION ( - ( 24 * 60 + 9 ))
#define MEASUREMENT_TIME 10
#define SATURATION_TIME 1
#define MARGIN_TIME 1
#define CYCLE ( 2 * ( MEASUREMENT_TIME + SATURATION_TIME + MARGIN_TIME ) )

// constants about recording
#define EVENT_MAX 100	// the initial number of rows of matrix for data (if shorted, automatically extended)
#define LOG_MAX 100	// the initial number of rows of matrix for log (if shorted, automatically extended)
#define TAKE_LOG_CYCLE 10	// the number of acquired events per turns of this number is recorded in log 

enum Direction{ Up, Down, DirectionCount };
enum Switch{ On, Off };
enum StationNumber{ CurrentRelay = 1, ResistanceRelay = 2, ADC = 13 };
enum FileVariety{ DataForUp, DataForDown, Log, FileVarietyCount };

struct Matrix{

	int **matrix;
	unsigned int row, column;
};


void PrintHelp( void );
void CheckFile( char *arg, char **FileName );
unsigned long GetSeconds( char *arg );

void InitilizeCAMAC( void );
void ClearCAMAC( enum StationNumber ModuleStation );
void SwitchCurrent( enum Direction CurrentDirection );
void SwitchResistance( enum Switch ResistanceSwitch );
void wait( unsigned int blank );
void PrintDate( time_t GivenTime );	// display both date and time of given time and get a newline
void FprintDate( FILE *file, time_t GivenTime );
void PrintOnlyTime( time_t GivenTime );	// display only time of given time and get a newline

void GetMatrix( struct Matrix *data );
void InitilizeMatrix( struct Matrix *data );
void ExtendMatrix( struct Matrix *data, unsigned int extend );
void FreeMatrix( struct Matrix *data );

void StartMessage( unsigned long DataTakingTurns, int *ADCchannel );
unsigned int GetData( enum Direction direction, int *ADCchannel, struct Matrix *data );
void EndMessage( unsigned int DataTakingTurns, unsigned int *total, char **FileName );
void WriteData( struct Matrix *data, char *DataFileName );
void GetLog( unsigned int *get, struct Matrix *DataLog );
void WriteLog( unsigned int DataTakingTurns, unsigned int *total, struct Matrix *DataLog, int *ADCchannel, char **FileName );


int main( int argc, char *argv[] ){

	int i;
	int *ADCchannel;
	unsigned int i_cycle = 0;
	unsigned int total[ (int)DirectionCount ] = { 0 }, get[ (int)DirectionCount ] = { 0 };
	unsigned long DataTakingTurns;
	char *FileName[ (int)FileVarietyCount ];	// 0 : datafile for up direction, 1 : datafile for down direction, 2 : logfile
	struct Matrix data = { 0, EVENT_MAX, 1 };
	struct Matrix DataLog = { 0, LOG_MAX, (int)DirectionCount };

// Check the number of arguments
	if( argc < 4 ){
		PrintHelp();
		exit(1);
	}

// Check whether the datafiles and logfile are available
	CheckFile( argv[1], FileName );

// Get the number of datataking cycle
	DataTakingTurns = GetSeconds( argv[2] ) / CYCLE;

// Get ADC channel numbers to take data from
	ADCchannel = malloc( sizeof(int) * ( argc-2 ) );
	if( ADCchannel == NULL ){
		printf("Failed to allocate an array for ADC channel.\n");
		exit( 1 );
	}
	for( i=0 ; i<argc-3 ; i++ ){
		ADCchannel[ i ] = atoi( argv[ i+3 ] );
		if( ADCchannel[ i ] < ADC_CHANNEL_MIN || ADCchannel[ i ] > ADC_CHANNEL_MAX ){
			printf("Invalid ADC channel number : %s\n", argv[ i+3 ]);
			exit( 1 );
		}
	}
	ADCchannel[ i ] = -1;

// Get a matrix for data
	data.column = argc - 3;
	GetMatrix( &data );
	InitilizeMatrix( &data );

// Get a matrix for log
	GetMatrix( &DataLog );
	InitilizeMatrix( &DataLog );

// Get CAMAC ready
	if( CAMOPN() ){
		printf("CAMAC open error.\n");
		exit( 1 );
	}
	InitilizeCAMAC();
	ClearCAMAC( CurrentRelay );
	ClearCAMAC( ResistanceRelay );
	ClearCAMAC( ADC );

// Start datataking
	StartMessage( DataTakingTurns, ADCchannel );
	WriteLog( i_cycle, total, &DataLog, ADCchannel, FileName );

	for( i_cycle=0 ; i_cycle<DataTakingTurns ; i_cycle++ ){

		printf("%6d th turn datataking ---------- ", i_cycle+1);
		PrintDate( time( NULL ) + TIME_CORRECTION );
		for( i=0 ; i<(int)DirectionCount ; i++ ){

			get[ i ] = GetData( (enum Direction)i, ADCchannel, &data );
			WriteData( &data, FileName[ i ] );
			InitilizeMatrix( &data );
		}

		printf("get %d event(s) for up direction , %d event(s) for down direction\n", get[ (int)Up ], get[ (int)Down ]);
		for( i=0 ; i<(int)DirectionCount ; i++ ) total[ i ] += get[ i ];
		printf("Current total up : %d, down : %d\n", total[ (int)Up ], total[ (int)Down ]);
		GetLog( get, &DataLog );
		WriteLog( i_cycle + 1, total, &DataLog, ADCchannel, FileName );

		printf("\a");
	}

	EndMessage( DataTakingTurns, total, FileName );

// free allocated memory block
	FreeMatrix( &data );
	for( i=0 ; i<(int)FileVarietyCount ; i++ ) free( FileName[ i ] );
	free( ADCchannel );

	CAMCLS();

	return 0;
}



void PrintHelp( void ){

	printf("Necessary arguments :\n");
	printf("\t1. filename ........... '.' and extension are not needed\n");
	printf("\t2. data taking time ... integer + 'h'/'m'/'s'\n");
	printf("\t3. ADC channel ........ must be divided by space if using more than 1 channel\n");

	return;
}

void CheckFile( char *arg, char **FileName ){

	unsigned int i, ArgLength;
	int c;
	FILE *file;

	ArgLength = strlen( arg );

	for( i=0 ; i<(int)FileVarietyCount ; i++ ){

	// get filename from the first argument
		FileName[ i ] = malloc( sizeof(char) * ( ArgLength + 10 ) );
		if( FileName[ i ] == NULL ){
			printf("Failed to allocate an array for the filename.\n");
			printf("Filename including pass may be too long.\n");
			exit( 1 );
		}

		if( i == (int)DataForUp ) sprintf(FileName[ i ], "%s_up.dat", arg);
		else if( i == (int)DataForDown ) sprintf(FileName[ i ], "%s_down.dat", arg);
		else sprintf(FileName[ i ], "%s.log", arg);

	// check overwriting
		if( (file = fopen(FileName[ i ], "r")) != NULL ){
			printf("File \"%s\" already exists. Relplace? (y/n)", FileName[ i ]);
			c = getchar();
			if( c != 'y' ){
				printf("Please retry with another filename.\n");
				fclose( file );
				free( FileName[ i ] );
				exit( 1 );
			}
			while( (c = getchar()) != '\n' ){
				; 
			}
			fclose( file );
		}

	// open file with write mode
		if( (file = fopen(FileName[ i ], "w")) == NULL ){
			printf("File \"%s\" can't open with write mode.\n", FileName[ i ]);
			exit( 1 );
		}
		fclose( file );
	}

	return;
}

unsigned long GetSeconds( char *arg ){

	unsigned long DataTakingTime;
	char *sign;

	DataTakingTime = strtoul( arg, &sign, 10 );

	if( !( strcmp( sign, "h" ) ) ) DataTakingTime *= 3600;
	else if( !( strcmp( sign, "m" ) ) ) DataTakingTime *= 60;
	else if( ( strcmp( sign, "s" ) ) && ( strcmp( sign, "" ) ) ){
		printf("Invalid time expression : %s\n", arg);
		exit(1);
	}

	return DataTakingTime;
}


void InitilizeCAMAC( void ){

	CSETCR(0);
	CGENZ();
	CGENC();
	CREMI();

	return;
}


void ClearCAMAC( enum StationNumber ModuleStation ){

	int N, A, F;
	int dumy, q, x;

	N = (int)ModuleStation; A = 0; F = CLR;
	CAMAC( NAF( N, A, F ), &dumy, &q, &x );
	return;
}

void SwitchCurrent( enum Direction CurrentDirection ){

	int N, A, F;
	int ref = ( CurrentDirection == Up ) ? CURRENT_UP : CURRENT_DOWN, q, x;

	N = (int)CurrentRelay; A = 0; F = WRITE;
	CAMAC( NAF( N, A, F ), &ref, &q, &x );

	return;
}

void SwitchResistance( enum Switch ResistanceSwitch ){

	int N, A, F;
	int ref = ( ResistanceSwitch == On ) ? RESISTANCE_ON : RESISTANCE_OFF, q, x;

	N = (int)ResistanceRelay; A = 0; F = WRITE;
	CAMAC( NAF( N, A, F ), &ref, &q, &x );

	return;
}

void wait( unsigned int blank ){

	time_t StartTime = time( NULL );

	while( difftime( time(NULL), StartTime ) < blank ){
		;
	}

	return;
}

void PrintDate( time_t GivenTime ){

	struct tm *ForPrint = localtime( &GivenTime );

	printf("%4d/%2d/%2d %2d:%2d:%2d\n",
		ForPrint->tm_year + 1900, ForPrint->tm_mon + 1, ForPrint->tm_mday,
		ForPrint->tm_hour, ForPrint->tm_min, ForPrint->tm_sec);

	return;
}

void FprintDate( FILE *file, time_t GivenTime ){

	struct tm *ForPrint = localtime( &GivenTime );

	fprintf(file, "%4d/%2d/%2d %2d:%2d:%2d\n",
		ForPrint->tm_year + 1900, ForPrint->tm_mon + 1, ForPrint->tm_mday,
		ForPrint->tm_hour, ForPrint->tm_min, ForPrint->tm_sec);

	return;
}

void PrintOnlyTime( time_t GivenTime ){

	struct tm *ForPrint = localtime( &GivenTime );

	printf("%2d:%2d:%2d\n", ForPrint->tm_hour, ForPrint->tm_min, ForPrint->tm_sec);

	return;
}

void GetMatrix( struct Matrix *data ){

	unsigned int i;

	data->matrix = malloc( sizeof(int*) * (data->row) );
	for( i=0 ; i<data->row ; i++ ){
		data->matrix[ i ] = malloc( sizeof(int) * (data->column) );
	}

	return;
}

void InitilizeMatrix( struct Matrix *data ){


	unsigned int i, j;

	for( i=0 ; i<data->row ; i++ ){
		for( j=0 ; j<data->column ; j++ ){
			data->matrix[ i ][ j ] = 0;
		}
	}

	return;
}

void ExtendMatrix( struct Matrix *data, unsigned int extend ){

	unsigned int i, j;

	data->row += extend;
	data->matrix = realloc( data->matrix, sizeof(int*) * (data->row) );
	for( i=0 ; i<extend ; i++ ){
		data->matrix[ data->row - extend + i ] = malloc( sizeof(int) * (data->column) );
		for( j=0 ; j<data->column ; j++ ) data->matrix[ data->row - extend + i ][ j ] = 0;
	}

	return;
}

void FreeMatrix( struct Matrix *data ){

	unsigned int i;

	for( i=0 ; i<data->row ; i++ ) free( data->matrix[ i ] );
	free( data->matrix );

	return;
}


void StartMessage( unsigned long DataTakingTurns, int *ADCchannel ){

	unsigned int i;
	time_t StartTime = time( NULL ), EndTime;

	EndTime = StartTime + DataTakingTurns * CYCLE;

	printf("\n");
	printf("--------------------\n");
	printf(" start time         : ");
	PrintDate( StartTime + TIME_CORRECTION );
	printf(" end time           : ");
	PrintDate( EndTime + TIME_CORRECTION );
	printf(" datataking time    : %d h %2d m %2d s\n",
		(long)difftime(EndTime, StartTime)/3600, ((long)difftime(EndTime, StartTime) % 3600)/60, (long)difftime(EndTime, StartTime) % 60);
	printf(" datataking turns   : %d\n", DataTakingTurns);
	printf(" 1 cycle            : %d seconds\n", CYCLE);
	printf("    (saturation : %d s +  margin : %d s + measurement : %d s)\n", SATURATION_TIME, MARGIN_TIME, MEASUREMENT_TIME);
	printf(" ADC station number : %d\n", ADC);
	printf(" ADC channel number : ");
	for( i=0 ; ; i++ ){
		printf("%2d", ADCchannel[i]);
		if( ADCchannel[ i+1 ]  == -1 ){
			printf("\n");
			break;
		}
		else printf(" ");
	}
	printf(" Relay MUX. for current reverse :\n");
	printf("   station number : %2d\n", CurrentRelay);
	printf("   relay off : %X ch(up direction)\n", CURRENT_UP);
	printf("   relay on  : %X ch(down direction, cable is inserted)\n", CURRENT_DOWN);
	printf(" Relay MUX. for resistance switch :\n");
	printf("   station number : %2d\n", ResistanceRelay);
	printf("   relay off : %X ch(for saturation)\n", RESISTANCE_OFF);
	printf("   relay on  : %X ch(for measurement, cable is inserted)\n", RESISTANCE_ON);
	printf("--------------------\n");
	printf("\n");

	printf("Start datataking...\n");

	return;
}

unsigned int GetData( enum Direction direction, int *ADCchannel, struct Matrix *data ){

	unsigned int i, j, events = 0;
	int N, A, F;
	int dumy, ref, q, x;
	time_t StartTime, CurrentTime;

// saturate target magnetization
	SwitchCurrent( direction );
	SwitchResistance( Off );
	wait( SATURATION_TIME );

// change current to apropriate value
	SwitchResistance( On );
	wait( MARGIN_TIME );

// start datataking
	InitilizeCAMAC();
	ClearCAMAC( ADC );
	StartTime = time( NULL );

	while( difftime( time(NULL), StartTime ) < MEASUREMENT_TIME ){

	// test LAM
		N = ADC; A = 0; F = LAM;
		CAMAC( NAF( N, A, F ), &dumy, &q, &x );

		if( q == 1 ){
			CurrentTime = time( NULL );
			for( i=0 ; ADCchannel[ i ] != -1 ; i++ ){

				if( events >= data->row - 1 ) ExtendMatrix( data, EVENT_MAX );

			// read data
				N = (int)ADC; A = ADCchannel[ i ]; F = READ;
				CAMAC( NAF( N, A, F ), &ref, &q, &x );

			// print and write data to display and data matrix respectively
				printf("%6d ", ref);
				data->matrix[ events ][ i ] = ref;
			}

			printf(" ");
			if( direction == Up ) printf(" up ");
			else printf("down");
			printf(" %6d th data : %2ds ", ++events, (long)difftime( CurrentTime, StartTime ));
			PrintOnlyTime( CurrentTime + TIME_CORRECTION );

			ClearCAMAC( ADC );
		}

		CREMI();
	}

	if( events == 0 ) printf("(No data was gettton.)\n");
	data -> matrix[ events ][ 0 ] = -1;
	printf("\n");

	return events;
}

void EndMessage( unsigned int DataTakingTurns, unsigned int *total, char **FileName ){

	printf("\n");
	printf("--------------------\n");
	printf("Datataking has successfully finished at ");
	PrintDate( time( NULL ) + TIME_CORRECTION );
	printf("Took data for %d turns.\n", DataTakingTurns);
	printf("Get totally %d events for up direction and %d events for down direction.\n", total[ (int)Up ], total[ (int)Down ] );
	printf("The data was written in \"%s\"(for up direction) and \"%s\"(for down direction), and the log was in \"%s\".\n",
		FileName[ (int)DataForUp ], FileName[ (int)DataForDown ], FileName[ (int)Log ]);
	printf("\n");

	return;
}

void WriteData( struct Matrix *data, char *DataFileName ){

	unsigned int i, j;
	FILE *DataFile;

	if( (DataFile = fopen(DataFileName, "a")) == NULL ){
		printf("File \"%s\" open error.\n", DataFileName);
		exit( 1 );
	}

	for( i=0 ; data->matrix[ i ][ 0 ] != -1 ; i++ ){
		for( j=0 ; j<data->column ; j++ ){
			fprintf(DataFile, "%6d", data->matrix[ i ][ j ]);
			if( j == data->column - 1 ) fprintf(DataFile, "\n");
			else fprintf(DataFile, " ");
		}
	}

	fprintf(DataFile, "\n");

	fclose( DataFile );

	return;
}

void GetLog( unsigned int *get, struct Matrix *DataLog ){

	unsigned int i;
	static unsigned int CurrentLog = 0, CurrentTurn = 0;

	if( CurrentTurn == TAKE_LOG_CYCLE ){
		CurrentLog++;
		DataLog->matrix[ CurrentLog ][ (int)Up ] = 0;
		CurrentTurn = 0;
	}
	if( CurrentLog >= (DataLog->row - 1) ) ExtendMatrix( DataLog, LOG_MAX );
	if( CurrentTurn == 0 ){ DataLog->matrix[ CurrentLog + 1 ][ (int)Up ] = -1;}

	for( i=0 ; i<(int)DirectionCount ; i++ ){
		DataLog->matrix[ CurrentLog ][ i ] += get[ i ];
	}

	CurrentTurn++;

	return;
}

void WriteLog( unsigned int DataTakingTurns, unsigned int *total, struct Matrix *DataLog, int *ADCchannel, char **FileName ){

	unsigned int i;
	static time_t StartTime;
	time_t EndTime;
	FILE *LogFile;

	if( DataTakingTurns == 0 ) StartTime = time( NULL );
	if( (LogFile = fopen(FileName[ (int)Log ], "w")) == NULL ){
		printf("File \"%s\" open error.\n", FileName[ (int)Log ]);
		exit( 1 );
	}

	EndTime = time( NULL );

	fprintf(LogFile, "The log of \"%s\" and \"%s\".\n", FileName[ (int)DataForUp ], FileName[ (int)DataForDown ]);
	fprintf(LogFile, "\n");
	
	fprintf(LogFile, " datataking turns   : %d\n", DataTakingTurns);
	fprintf(LogFile, " events             : %d for up direction\n", total[ (int)Up ]);
	fprintf(LogFile, "                    : %d for down dirction\n", total[ (int)Down ]);
	fprintf(LogFile, "     (each per %d seconds)\n", DataTakingTurns * MEASUREMENT_TIME);
	fprintf(LogFile, "\n");

	fprintf(LogFile, " start time         : ");
	FprintDate( LogFile, StartTime + TIME_CORRECTION );
	fprintf(LogFile, " end time           : ");
	FprintDate( LogFile, EndTime + TIME_CORRECTION );
	fprintf(LogFile, " datataking time    : %d h %2d m %2d s\n",
		(long)difftime(EndTime, StartTime)/3600, ((long)difftime(EndTime, StartTime) % 3600)/60, (long)difftime(EndTime, StartTime) % 60);

	fprintf(LogFile, "\n");
	fprintf(LogFile, " 1 cycle            : %d seconds\n", CYCLE);
	fprintf(LogFile, "    (saturation : %d s +  margin : %d s + measurement : %d s)\n", SATURATION_TIME, MARGIN_TIME, MEASUREMENT_TIME);
	fprintf(LogFile, " ADC station number : %d\n", (int)ADC);
	fprintf(LogFile, " ADC channel number : ");
	for( i=0 ; ; i++ ){
		fprintf(LogFile, "%2d", ADCchannel[ i ]);
		if( ADCchannel[ i+1 ]  == -1 ){
			fprintf(LogFile, "\n");
			break;
		}
		else fprintf(LogFile, " ");
	}
	fprintf(LogFile, " Relay MUX. for current reverse :\n");
	fprintf(LogFile, "   station number : %2d\n", (int)CurrentRelay);
	fprintf(LogFile, "   relay off : %X ch(up direction)\n", CURRENT_UP);
	fprintf(LogFile, "   relay on  : %X ch(down direction, cable is inserted)\n", CURRENT_DOWN);
	fprintf(LogFile, " Relay MUX. for resistance switch :\n");
	fprintf(LogFile, "   station number : %2d\n", (int)ResistanceRelay);
	fprintf(LogFile, "   relay off : %X ch(for saturation)\n", RESISTANCE_OFF);
	fprintf(LogFile, "   relay on  : %X ch(for measurement, cable is inserted)\n", RESISTANCE_ON);
	fprintf(LogFile, "--------------------\n");
	fprintf(LogFile, "\n");

	if( DataTakingTurns != 0 ){
		fprintf(LogFile, "counts per %d cycles :\n", TAKE_LOG_CYCLE);
		fprintf(LogFile, "    turn   \t   up    down\n");
		for( i=0 ; DataLog->matrix[ i+1 ][ (int)Up ] != -1 ; i++ ){
			fprintf(LogFile, "%4d - %4d\t%6d %6d\n",
				i * TAKE_LOG_CYCLE + 1, (i + 1) * TAKE_LOG_CYCLE,DataLog->matrix[ i ][ (int)Up ], DataLog->matrix[ i ][ (int)Down ]);
		}
		fprintf(LogFile, "%4d - %4d\t%6d %6d\n",
			i * TAKE_LOG_CYCLE + 1, DataTakingTurns ,DataLog->matrix[ i ][ (int)Up ], DataLog->matrix[ i ][ (int)Down ]);
	}

	fclose( LogFile );

	return;
}