/**********************************************************************
 * zoom block sdk main
 *********************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <getopt.h>
#include <unistd.h>
#include <pthread.h>
#include <signal.h>
#include <sys/stat.h>

#include "spi_access.h"

#define	SPI_ADC_FUNC_NONE				0
#define	SPI_ADC_FUNC_LOOP_THREAD		1
#define	SPI_ADC_FUNC_GET_8CHANNELS		2
#define	SPI_ADC_FUNC_SET_CONF_8CHANNELS	3
#define	SPI_ADC_FUNC_READ_8CHANNELS		4
#define	SPI_ADC_FUNC_READ_1CHANNELS		5
#define	SPI_ADC_FUNC_RESET				6

#define MAX11636_BUFF_MAX	16

//#define	__DEBUG__
#define SPI_ADC_PID_PATH	"/var/run/spi_adc.pid"
static sigset_t	s_sigset;
static int daemonize(void);
static int mask_signals(sigset_t* p_sigset);
static int wait_signals(sigset_t* p_sigset, char *pid_file_path);

static int gSpiLoopRun = 0;
static void *SpiAdcLoopThread(void* arg);
static void SpiAdcLoopThreadStop(void);

static void SpiAdcUsage(void)
{
	fprintf(stderr, "Usage: zoom_block_test [options]\n\n"
		"Options:\n"
		"-f | --fuction   Test function number\n" 
		"       1:Loop\n"
		"       2:Get one time\n"
		"       3:set conf 8ch\n"
		"       4:read 8ch\n"
		"       5:read 1ch\n"
		"       6:Reset\n"
		"-a | --addr      Adderess\n"
		"-d | --data      Write Data\n"
		"-g | --gpio      GPIO port\n"
		"-l | --length    Data Length\n"
		"-b | --debug     Debug Mode On\n"
		"-h | --help      Print this message\n\n");
}

static void print_rx_buf(unsigned char rx_buf[], int length_of_rx_buf);
static void achieve_adc_value(unsigned short adc_value[], unsigned char rx_buf[], int length_of_rx_buf);

static struct option long_options[] ={
	{"function",    required_argument, 	0, 'f' 	},
	{"addr",        required_argument, 	0, 'a' 	},
	{"data",        required_argument, 	0, 'd' 	},
	{"gpio",        required_argument, 	0, 'g' 	},
	{"length",      required_argument, 	0, 'l' 	},
	{"debug",       required_argument, 	0, 'b' 	},
	{"help",        no_argument,        0, 'h' 	},
	{0, 0, 0, 0}
};

typedef struct _FW_SPI_ADC_ARGS {
	int 	Function;
	int 	Addr;
	int 	Data;
	int 	Gpio;
	int 	DataLeng;
	int 	Debug;
}FW_SPI_ADC_ARGS, *pFW_SPI_ADC_ARGS; 
#define DEFAULT_FW_SPI_ADC_ARGS {0,0,0,0,0,1}

static int FwSpiAdcParseArgs(int argc, char *argv[], pFW_SPI_ADC_ARGS p_args)
{
	int opt;

	if ( argc < 2){ 
		return -1; 
	}

	while (1) {
		/* getopt_long stores the option index here. */
		int option_index = 0;
		opt = getopt_long_only (argc, (char**)argv, "f:a:d:g:l:bh", long_options, &option_index);
		/* Detect the end of the options. */
		if (opt == -1)
			break;

		switch (opt) {
			case 0:
				/* If this option set a flag, do nothing else now. */
				if (long_options[option_index].flag != 0)
					break;
				break;
			case 'f':
				p_args->Function = strtol(optarg, NULL, 0);
				break;
			case 'a':
				p_args->Addr = strtol(optarg, NULL, 0);
				break;
			case 'd':
				p_args->Data = strtol(optarg, NULL, 0);
				break;
			case 'g':
				p_args->Gpio = strtol(optarg, NULL, 0);
				break;
			case 'l':
				p_args->DataLeng = strtol(optarg, NULL, 0);
				break;
			case 'b':
				p_args->Debug = strtol(optarg, NULL, 0);
				break;
			case 'h':
				SpiAdcUsage();
				return 0;
				break;
			default:
				break;
		}
	}
	return 0;
}

int main(int argc, char *argv[])
{
	pJETSON_SPI_CTRL pSpiCtrl=NULL;
	int txrx_size;
	unsigned char tx_buf[MAX11636_BUFF_MAX];
	unsigned char rx_buf[MAX11636_BUFF_MAX];
	unsigned short adc_value[MAX11636_BUFF_MAX/2];

	pthread_t spi_adc_loop_pthd;

	FW_SPI_ADC_ARGS	FwSpiAdcArgs = DEFAULT_FW_SPI_ADC_ARGS;
	FwSpiAdcParseArgs(argc, argv, &FwSpiAdcArgs);

	if(FwSpiAdcArgs.Function == 0){
		SpiAdcUsage();
		return -1;
	}

	fprintf(stderr, "spi_adc options:\n"
		"-f | --fuction   = %d\n"
		"-a | --addr      = %d\n"
		"-d | --data      = %d\n"
		"-g | --gpio      = %d\n"
		"-l | --length    = %d\n"
		"-b | --debug     = %d\n\n",
        FwSpiAdcArgs.Function,
        FwSpiAdcArgs.Addr,
        FwSpiAdcArgs.Data,
        FwSpiAdcArgs.Gpio,
        FwSpiAdcArgs.DataLeng,
	FwSpiAdcArgs.Debug);

    switch(FwSpiAdcArgs.Function){
	case SPI_ADC_FUNC_GET_8CHANNELS :       //2
		{
			fprintf(stderr, "%s=%d, SPI_ADC_FUNC_GET_8CHANNELS\n", __FUNCTION__, __LINE__);

			//Open================================================================================
			if( (pSpiCtrl = SpiAccOpenDev()) == NULL ){
				fprintf(stderr, "SpiAccOpenDev() Error!!!\n");
				return -1;
			}
			memset(tx_buf, 0x00, MAX11636_BUFF_MAX);
			memset(rx_buf, 0x00, MAX11636_BUFF_MAX);
			//0x18================================================================================
			tx_buf[0] = 0x18;
			txrx_size = 1;
			SpiAccTransferDev( pSpiCtrl, txrx_size, tx_buf, rx_buf);
			fprintf(stderr, "SPI Access tx_buf[0]=0x%02x, \n", tx_buf[0]);

			//0xB8================================================================================
			tx_buf[0] = 0xB8;
			txrx_size = 1;
			SpiAccTransferDev( pSpiCtrl, txrx_size, tx_buf, rx_buf);
			fprintf(stderr, "SPI Access tx_buf[0]=0x%02x, \n", tx_buf[0]);

			//Wait================================================================================
			usleep(1);

			//Read================================================================================
			memset(tx_buf, 0x00, MAX11636_BUFF_MAX);
			memset(rx_buf, 0x00, MAX11636_BUFF_MAX);
			txrx_size = MAX11636_BUFF_MAX;
			SpiAccTransferDev( pSpiCtrl, txrx_size, tx_buf, rx_buf);
			fprintf(stderr, "SPI Access rx_buf[0]=0x%02x, rx_buf[1]=0x%02x\n", rx_buf[0], rx_buf[1]);
			
			print_rx_buf(rx_buf, MAX11636_BUFF_MAX);
			achieve_adc_value(adc_value, rx_buf, MAX11636_BUFF_MAX);

			SpiAccCloseDev( pSpiCtrl );
		}
		break;

	case SPI_ADC_FUNC_SET_CONF_8CHANNELS :       //3
		{
			fprintf(stderr, "%s=%d, SPI_ADC_FUNC_GET_8CHANNELS\n", __FUNCTION__, __LINE__);
			//Open================================================================================
			if( (pSpiCtrl = SpiAccOpenDev()) == NULL ){
			fprintf(stderr, "SpiAccOpenDev() Error!!!\n");
				return -1;
			}

			//0xB8================================================================================
			memset(tx_buf, 0x00, MAX11636_BUFF_MAX);
			memset(rx_buf, 0x00, MAX11636_BUFF_MAX);
			tx_buf[0] = 0xB8;
			txrx_size = 1;
			SpiAccTransferDev( pSpiCtrl, txrx_size, tx_buf, rx_buf);
			fprintf(stderr, "SPI Access tx_buf[0]=0x%02x\n", tx_buf[0]);
			SpiAccCloseDev( pSpiCtrl );
		}
		break;

	case SPI_ADC_FUNC_READ_8CHANNELS :       //4
		{
			fprintf(stderr, "%s=%d, SPI_ADC_FUNC_GET_8CHANNELS\n", __FUNCTION__, __LINE__);
			//Open================================================================================
			if( (pSpiCtrl = SpiAccOpenDev()) == NULL ){
			fprintf(stderr, "SpiAccOpenDev() Error!!!\n");
				return -1;
			}

			//Read================================================================================
			memset(tx_buf, 0x00, MAX11636_BUFF_MAX);
			memset(rx_buf, 0x00, MAX11636_BUFF_MAX);
			txrx_size = MAX11636_BUFF_MAX;
			SpiAccTransferDev( pSpiCtrl, txrx_size, tx_buf, rx_buf);
			fprintf(stderr, "SPI Access rx_buf[0]=0x%02x, rx_buf[1]=0x%02x\n", rx_buf[0], rx_buf[1]);
			
			print_rx_buf(rx_buf, MAX11636_BUFF_MAX);
			achieve_adc_value(adc_value, rx_buf, MAX11636_BUFF_MAX);

			SpiAccCloseDev( pSpiCtrl );
		}
		break;
	case SPI_ADC_FUNC_READ_1CHANNELS :       //5
		{
			fprintf(stderr, "%s=%d, SPI_ADC_FUNC_GET_8CHANNELS\n", __FUNCTION__, __LINE__);
			//Open================================================================================
			if( (pSpiCtrl = SpiAccOpenDev()) == NULL ){
			fprintf(stderr, "SpiAccOpenDev() Error!!!\n");
				return -1;
			}

			//0xB8================================================================================
			memset(tx_buf, 0x00, MAX11636_BUFF_MAX);
			memset(rx_buf, 0x00, MAX11636_BUFF_MAX);
			txrx_size = 1;
			SpiAccTransferDev( pSpiCtrl, txrx_size, tx_buf, rx_buf);
			fprintf(stderr, "SPI Access tx_buf[0]=0x%02x\n", tx_buf[0]);
			SpiAccCloseDev( pSpiCtrl );
		}
		break;
	case SPI_ADC_FUNC_RESET :       //6
		{
			fprintf(stderr, "%s=%d, SPI_ADC_FUNC_RESET\n", __FUNCTION__, __LINE__);
			//Open================================================================================
			if( (pSpiCtrl = SpiAccOpenDev()) == NULL ){
			fprintf(stderr, "SpiAccOpenDev() Error!!!\n");
				return -1;
			}
/*
			//0x18================================================================================
			memset(tx_buf, 0x00, MAX11636_BUFF_MAX);
			memset(rx_buf, 0x00, MAX11636_BUFF_MAX);
			tx_buf[0] = 0x18;	// FIFO Reset
			txrx_size = 1;
			SpiAccTransferDev( pSpiCtrl, txrx_size, tx_buf, rx_buf);
			fprintf(stderr, "SPI Access tx_buf[0]=0x%02x\n", tx_buf[0]);
*/			
			//0x10================================================================================
			tx_buf[0] = 0x10;	// All Reset
			txrx_size = 1;
			SpiAccTransferDev( pSpiCtrl, txrx_size, tx_buf, rx_buf);
			fprintf(stderr, "SPI Access tx_buf[0]=0x%02x\n", tx_buf[0]);
			SpiAccCloseDev( pSpiCtrl );

		}
		break;

        case SPI_ADC_FUNC_LOOP_THREAD :       //1
			fprintf(stderr, "SPI_ADC_LOOP_THREAD_FUNC\n");

			if(FwSpiAdcArgs.Debug == 0){
				daemonize();
			}

			mask_signals(&s_sigset);
			printf("main:pthread_create auto_focus_thread()\n");
			if ( pthread_create(&spi_adc_loop_pthd, NULL, SpiAdcLoopThread, NULL) != 0){
				printf("main:pthread_create return error for SpiAdcLoopThread()\n");

			}
			//================================================================
			fprintf(stderr, "Wait for the sigwait thread to receive SIGTERM or SIGINT\n");
			wait_signals(&s_sigset, SPI_ADC_PID_PATH);
			fprintf(stderr, "Received signal SIGTERM or SIGINT\n");
			//================================================================
			SpiAdcLoopThreadStop();
			pthread_cancel(spi_adc_loop_pthd);
			pthread_join(spi_adc_loop_pthd, NULL);
            break;

	case SPI_ADC_FUNC_NONE :
        default : 
            SpiAdcUsage();
    }

	return 0;
}



static int daemonize(void)
{
	pid_t	pid;

	// daemon initialzation
	if ( (pid = fork()) < 0 )
		return -1;
	else if (pid != 0)
		exit(0);		// parent goes bye-bye
		
	// child continues
	setsid();			// become session leader
	chdir("/");			// change working directory
	umask(0);			// clear our file mode creation mask
	return 0;
}

static int mask_signals(sigset_t* p_sigset)
{
	int		retcode;

	// Mask Signal
	signal( SIGPIPE, SIG_IGN );
	sigemptyset(p_sigset);
	sigaddset(p_sigset, SIGTERM);
	sigaddset(p_sigset, SIGINT);
	sigaddset(p_sigset, SIGUSR1);
	sigaddset(p_sigset, SIGUSR2);

	if ((retcode = pthread_sigmask(SIG_BLOCK, p_sigset, NULL)) != 0)
		fprintf(stderr, "[fwvemd] pthread_sigmask err %d\n", retcode);

	return 0;
}

static int wait_signals(sigset_t* p_sigset, char *pid_file_path)
{
	int	signum;
	
	FILE* fp;
	if ( (fp=fopen( pid_file_path, "wt")) == NULL ) {
		fprintf(stderr, "[%s] fopen %s failed.\n", __FUNCTION__, pid_file_path);
	} else {
		fprintf(fp, "%d\n", getpid());
		fclose( fp );
	}

	while (1) {
		sigwait(p_sigset, &signum);

		if (signum == SIGINT) {
			fprintf(stderr, "\nGot SIGINT\n");
			break;
		}
		else if (signum == SIGTERM) {
			fprintf(stderr, "\nGot SIGTERM\n");
			break;
		}
		else {
			fprintf(stderr, "\n%s(%d): Got %d signal.\n", __FUNCTION__, __LINE__, signum);
		}
	}
	remove(pid_file_path);

	return signum;
}




static void SpiAdcLoopThreadStop(void)
{
	gSpiLoopRun = 0;
	sleep(1);
}


static void *SpiAdcLoopThread(void* arg)
{
	pJETSON_SPI_CTRL pSpiCtrl=NULL;
	int txrx_size;
	unsigned char tx_buf[MAX11636_BUFF_MAX];
	unsigned char rx_buf[MAX11636_BUFF_MAX];
	unsigned short adc_value[MAX11636_BUFF_MAX/2];

	memset(tx_buf, 0x00, MAX11636_BUFF_MAX);
	memset(rx_buf, 0x00, MAX11636_BUFF_MAX);

	//Open================================================================================
	if( (pSpiCtrl = SpiAccOpenDev()) == NULL ){
	fprintf(stderr, "SpiAccOpenDev() Error!!!\n");
		return -1;
	}


	//0x10================================================================================
	tx_buf[0] = 0x10;	// All Reset
	txrx_size = 1;
	SpiAccTransferDev( pSpiCtrl, txrx_size, tx_buf, rx_buf);
	fprintf(stderr, "SPI Access tx_buf[0]=0x%02x[All Reset]\n", tx_buf[0]);

	gSpiLoopRun = 1;
	while(gSpiLoopRun) {
			//0xB8================================================================================
			tx_buf[0] = 0xB8;	//Conversoin for 8 Channel ADC
			txrx_size = 1;
			SpiAccTransferDev( pSpiCtrl, txrx_size, tx_buf, rx_buf);
//			fprintf(stderr, "SPI Access tx_buf[0]=0x%02x, \n", tx_buf[0]);
//			//Wait================================================================================
			usleep(0);

			//Read================================================================================
			tx_buf[0] = 0x00;	// Read FIFO 8 Channel
			txrx_size = MAX11636_BUFF_MAX;
			SpiAccTransferDev( pSpiCtrl, txrx_size, tx_buf, rx_buf);
//			fprintf(stderr, "SPI Access rx_buf[0]=0x%02x, rx_buf[1]=0x%02x\n", rx_buf[0], rx_buf[1]);

			//0x18================================================================================
			tx_buf[0] = 0x18;	// Reset FIFO only
			txrx_size = 1;
			SpiAccTransferDev( pSpiCtrl, txrx_size, tx_buf, rx_buf);
//			fprintf(stderr, "SPI Access tx_buf[0]=0x%02x, \n", tx_buf[0]);

//			print_rx_buf(rx_buf, MAX11636_BUFF_MAX);
//			achieve_adc_value(adc_value, rx_buf, MAX11636_BUFF_MAX);
	}

	SpiAccCloseDev( pSpiCtrl );

	return NULL;		
}


static void print_rx_buf(unsigned char rx_buf[], int length_of_rx_buf)
{
	printf("%s\n",__FUNCTION__);
	for (int nIdx = 0; nIdx < length_of_rx_buf; nIdx++)
	{
		printf("0x%02x ", rx_buf[nIdx]);

	}
	printf("\n");
}

static void achieve_adc_value(unsigned short adc_value[], unsigned char rx_buf[], int length_of_rx_buf)
{
	printf("%s\n",__FUNCTION__);
	for (int nIdx = 0; nIdx < (length_of_rx_buf/2); nIdx++)
	{
		adc_value[nIdx] = ((unsigned short)(rx_buf[(nIdx * 2)]&0x0f)) << 8 | (unsigned short)rx_buf[(nIdx * 2) + 1];
		printf("0x%04x ", adc_value[nIdx]);
	}
	printf("\n");
}