#include "os_config.h"

#include "c_def.h"
#include "debug.h"
//#include "oem.h"


#ifdef UART_RX_ENABLE

#include <stdarg.h>

#include "hw_uart.h"

#include "printf_fifo.h"
#include "scanf.h"


PRINTF_FIFO rxFiFo;
PRINTF_FIFO *prxfifo;

#define	RX_FIFO_SIZE	128

#if 0
static U8 rxFifoBuffer[RX_FIFO_SIZE];
#else
static U8 rxFifoBuffer[RX_FIFO_SIZE] __attribute__ ((section (".sdram_bss")));
#endif

//#define RICHARD

#ifdef RICHARD
//TX_MUTEX mutex_uart0_rx;

#define	UART_RX_EVENT_CHAR			0x01
#define	UART_RX_EVENT_LINE_DATA		0x02

TX_EVENT_FLAGS_GROUP gUartRxEvent;
#endif

#define	SCANF_UART_NUM		en_UART0

//static int scanfUartNum;


void scanf_init( void )
{
	UINT ret;
	
	//scanfUartNum	=	SCANF_UART_NUM;

	//ret = tx_mutex_create( &mutex_uart0_rx, NULL, TX_NO_INHERIT );
	//DBG_Assert( TX_SUCCESS == ret );

#ifdef RICHARD
	ret = tx_event_flags_create( &gUartRxEvent, NULL );	
	DBG_Assert( TX_SUCCESS == ret );
#endif
	
	prxfifo	=	&rxFiFo;
	printf_fifo_init( prxfifo, rxFifoBuffer, RX_FIFO_SIZE,
			NULL, NULL, NULL, NULL, NULL, NULL );
}



#ifdef UART_SCANF_ENABLE

#define	CHAR_ENTER		0x0d

#define	SCANF_MAX_SIZE	128

#if 0
static U8 inBuffer[SCANF_MAX_SIZE];
#else
static U8 inBuffer[SCANF_MAX_SIZE] __attribute__ ((section (".sdram_bss")));
#endif

extern PRINTF_FIFO *ptxfifo;


void scanf_rxPutCharCallback( char cha )
{
	U32	len;
	ULONG ret;
	ULONG flag;
	
	len = fifo_iput( ptxfifo, &cha, 1 );
	DBG_Assert( len == 1 );

	flag = UART_RX_EVENT_CHAR;
	if( CHAR_ENTER == cha )	flag |=	UART_RX_EVENT_LINE_DATA;

#ifdef RICHARD
	ret = tx_event_flags_set( &gUartRxEvent, flag, TX_OR );
#else
	ret = tx_event_flags_set( &event_grop, flag, TX_OR );
#endif
	DBG_Assert( ret == TX_SUCCESS );
}

static int inputb( char *buf, int size )
{
}

static int inputLine( char *buf, int bufSize )
{
	U32	len1, len2;
	UINT ret;
	ULONG flag;
	
#ifdef RICHARD
	ret = tx_event_flags_set( &gUartRxEvent, 0, TX_AND );
#else
	ret = tx_event_flags_set( &event_grop, ~(UART_RX_EVENT_LINE_DATA|UART_RX_EVENT_CHAR), TX_AND );
#endif
	DBG_Assert( ret == TX_SUCCESS );	
	
	while(1) {
		len1	=	fifo_getDataSize( prxfifo );
		len2	=	fifo_peekChar( prxfifo, CHAR_ENTER );
		
		if( (len1 == 0) || (len2 == 0) ) {
#ifdef RICHARD
			ret = tx_event_flags_get( &gUartRxEvent, UART_RX_EVENT_LINE_DATA,
				TX_OR_CLEAR, &flag, TX_WAIT_FOREVER );
#else
			ret = tx_event_flags_get( &event_grop, UART_RX_EVENT_LINE_DATA,
				TX_OR_CLEAR, &flag, TX_WAIT_FOREVER );
#endif
			DBG_Assert( ret == TX_SUCCESS );	
			DBG_Assert( flag == UART_RX_EVENT_LINE_DATA );	
		}
		else {
			DBG_Assert( bufSize >= len2 );
			
			if( len2 > bufSize )	len2 = bufSize;
			len1	=	fifo_get( prxfifo, buf, len2 );

			break;
		}
		
	}
	
	return len1;
}

int mygets( char *buf, int bufSize )
{
	int	len1;
	
	ULONG ret;
	
	ret = tx_mutex_get( &mutex_uart0_rx, TX_WAIT_FOREVER );
	DBG_Assert( ret == TX_SUCCESS );

	fifo_clear( prxfifo );

	len1	= inputLine( buf, bufSize - 1 );
	DBG_Assert( len1 < bufSize );
	buf[len1]	=	0;

	ret = tx_mutex_put( &mutex_uart0_rx );
	DBG_Assert( ret == TX_SUCCESS );
	
	return len1;
}

int mywaitcharEnter( void )
{
	int cha = mygetchar();
	
	return (cha == CHAR_ENTER);
}

int mygetcharSync( void )
{
	char chr;
	U32	len;
		
	ULONG ret;
	
	ret = tx_mutex_get( &mutex_uart0_rx, TX_WAIT_FOREVER );
	DBG_Assert( ret == TX_SUCCESS );

	len	=	fifo_getDataSize( prxfifo );
	chr = 0;
	if( len > 0 ) {
		len	=	fifo_get( prxfifo, &chr, 1 );		
		DBG_Assert( 1 == len );
	}
	
	ret = tx_mutex_put( &mutex_uart0_rx );
	DBG_Assert( ret == TX_SUCCESS );
	
	return chr;	
}

int mygetchar( void )
{
	ULONG ret;
	ULONG flag;

	char chr = 0;

	ret = tx_mutex_get( &mutex_uart0_rx, TX_WAIT_FOREVER );
	DBG_Assert( ret == TX_SUCCESS );

	fifo_clear( prxfifo );

#ifdef RICHARD
	ret = tx_event_flags_set( &gUartRxEvent, 0, TX_AND );
#else
	ret = tx_event_flags_set( &event_grop, ~(UART_RX_EVENT_LINE_DATA|UART_RX_EVENT_CHAR), TX_AND );
#endif
	DBG_Assert( ret == TX_SUCCESS );	

#ifdef RICHARD
	ret = tx_event_flags_get( &gUartRxEvent, UART_RX_EVENT_CHAR, TX_OR_CLEAR, &flag, TX_WAIT_FOREVER );
#else
	ret = tx_event_flags_get( &event_grop, UART_RX_EVENT_CHAR, TX_OR_CLEAR, &flag, TX_WAIT_FOREVER );
#endif
	DBG_Assert( ret == TX_SUCCESS );	
	DBG_Assert( flag == UART_RX_EVENT_CHAR );	
	DBG_assert( fifo_getDataSize( prxfifo ) );

	ret	=	fifo_get( prxfifo, &chr, 1 );		
	DBG_Assert( 1 == ret );

	ret = tx_mutex_put( &mutex_uart0_rx );
	DBG_Assert( ret == TX_SUCCESS );
	
	return chr;	
}

static int is_space( char chr )
{
	return (chr == ' ');
}

static int is_digital( char chr )
{
	return ( (chr >= '0') && (chr <= '9') );
}

static int is_xldigital( char chr )
{
	return ( ( (chr >= '0') && (chr <= '9') )
			|| ( (chr >= 'a') && (chr <= 'f') )  );
}

static int is_xhdigital( char chr )
{
	return ( ( (chr >= '0') && (chr <= '9') )
			|| ( (chr >= 'A') && (chr <= 'F') )  );
}

#define	GET_HHEX_NUM(x)	(	( (x) >= 'A') ? ( ( (x) - 'A') + 10 ) : ( (x) - '0')	)
#define	GET_LHEX_NUM(x)	(	( (x) >= 'a') ? ( ( (x) - 'a') + 10 ) : ( (x) - '0')	)

static unsigned int str2num( char **str, U8 base, U8 sign, U8 upcase )
{
	char *buf = *str;

	unsigned int uint;
	
	DBG_Assert( (base == 10) || (base == 16) );
	
	while( is_space( *buf ) )	++buf;
	
	if( sign ) {
		if( *buf == '-' ) {
			++buf;			
		}
		else {
			sign = FALSE;
		}
	}
	
	uint	=	0;
	if( base == 10 ) {
		while( is_digital( *buf ) ) {
			uint *=  10;
			uint +=	*buf ++  - '0';
		}
	}
	else {
		if( upcase ) {
			while( is_xhdigital( *buf ) ) {
				uint *=	16;
				uint +=	GET_HHEX_NUM(*buf);
				++buf;
			} 
		}
		else {
			while( is_xldigital( *buf ) ) {
				uint *=	16;
				uint +=	GET_LHEX_NUM(*buf);
				++buf;
			} 
		}
	}	
		
	*str	=	buf;	
	
	if(sign) {
		uint	=	-uint;
	}
	
	return uint;
}

static int mysscanf( char *buf, int datasize, const char *format, va_list args )
{
	char *buffer	=	buf;
	char *bufend	=	buf + datasize;

	char *str;
	int	*tint;
	unsigned int *tuint;
		
	while( *format ) {
		
		if( is_space( *format ) ) {
			while( is_space( *format ) )	++format ;
			while( is_space( *buf ) )	++buf;
			if( buf >= bufend ) break;
		}
		
		if( *format && (*format != '%' ) ) {
			if( *format ++ != *buf ++ ) {
				break;
			}
			if( buf >= bufend ) break;
			continue;
		}
		
		if( !*format )	break;
		++format;
		
		switch(*format ++ ) {
			case '%':
				if( *buf ++ != '%' )	return ( buf - buffer );
				break;
			
			case 'c':
				str		=	va_arg( args, char *);
				*str	=	*buf ++;	
				break;
					
			case 's':
				str	=	va_arg( args, char *);
				while( (*buf != ' ') && (*buf != CHAR_ENTER) ) {
					*str ++	=	*buf ++;
				}
				*str = 0;
				break;
			
			case 'd':
			case 'D':
				tint	=	(int*)va_arg( args, int * );
				*tint	=	(int)str2num( &buf, 10, TRUE, FALSE );
				break;
			
			case 'u':
			case 'U':
				tuint	=	(unsigned int*)va_arg( args, unsigned int * );
				*tuint	=	(unsigned int)str2num( &buf, 10, FALSE, FALSE );
				break;
			
			case 'x':
				tuint	=	(unsigned int*)va_arg( args, unsigned int * );
				*tuint	=	(unsigned int)str2num( &buf, 16, FALSE, FALSE );
				break;
			case 'X':
				tuint	=	(unsigned int*)va_arg( args, unsigned int * );
				*tuint	=	(unsigned int)str2num( &buf, 16, FALSE, TRUE );
				break;
			
			default:
				DBG_Assert(0);
		}

		if( buf >= bufend ) break;
				
	}
	
	return (buf - buffer);
}

int myscanf( const char *format, ... )
{
	int len1, len2;
	va_list vargs;
	
	ULONG ret;
	
	ret = tx_mutex_get( &mutex_uart0_rx, TX_WAIT_FOREVER );
	DBG_Assert( ret == TX_SUCCESS );

	fifo_clear( prxfifo );

	len1	= inputLine( inBuffer, SCANF_MAX_SIZE );
	DBG_Assert( len1 <= SCANF_MAX_SIZE );
	
	len2	=	0;
	if( --len1 > 0 ) {	// discard last ENTER char
		va_start( vargs, format );
		len2 = mysscanf( inBuffer, len1, format, vargs );
		DBG_Assert( len2 <= SCANF_MAX_SIZE );
		va_end( vargs );
	}
	
	
	ret = tx_mutex_put( &mutex_uart0_rx );
	DBG_Assert( ret == TX_SUCCESS );
	
	return len2;	
}
#endif //UART_SCANF_ENABLE

#endif //UART_RX_ENABLE