#include "os_config.h"

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

#include "regmap.h"
#include "mem_reloc.h"

#include "hw_uart.h"

#include <stdarg.h>
//#include "prj_def.h"
//#include "prj.h"
//#include "osconfig.h"
//#include "timer.h"

#include "printf_fifo.h"
#include "printf.h"

#ifdef UART_PRINTF_FIFO_ENABLE
#include "fifo.h"
#endif

#include <string.h>

#include "flash_boot.h"

#ifdef DAB_MODULE
#include "app_main.h"
#endif


#ifdef BOOT_FROM_FLASH
#undef UART0_USED_FOR_APP_UI
#undef UART1_USED_FOR_APP_UI

#if defined UART0_USED_FOR_UI_DEBUG
#define PRINTF_UART_NUM       en_UART0
#elif defined UART1_USED_FOR_UI_DEBUG
#define PRINTF_UART_NUM       en_UART1
#else
#define PRINTF_UART_NUM       en_UART2
#endif
#else
#undef UART0_USED_FOR_APP_UI
#undef UART1_USED_FOR_APP_UI

#if defined UART0_USED_FOR_UI_DEBUG
#define PRINTF_UART_NUM       en_UART0
#elif defined UART1_USED_FOR_UI_DEBUG
#define PRINTF_UART_NUM       en_UART1
#else
#define PRINTF_UART_NUM       en_UART2
#endif
#endif



#define	PRINTF_MAX_BUF  128
static U8 outBuffer[PRINTF_MAX_BUF];

PRINTF_FIFO txFiFo;
PRINTF_FIFO *ptxfifo;

#if 1//def BT_HCI_ENABLE
//#define TX_FIFO_SIZE    (256)
//#define TX_FIFO_SIZE    (256+32)
//#define TX_FIFO_SIZE    (256+64)
//#define TX_FIFO_SIZE    (256+256)
#define TX_FIFO_SIZE    1024
static U8 txFifoBuffer[TX_FIFO_SIZE];
#else
#define	TX_FIFO_SIZE	0x80000
static U8 txFifoBuffer[TX_FIFO_SIZE] __attribute__ ((section (".printf_debug_bss")));
#endif //BOOT_FROM_FLASH


#ifdef UART_PRINTF_FIFO_ENABLE
FIFO printf_fifo;// __USBHOST_BSS;
#endif


#ifdef UART_TX_FIFO_ENABLE
#define IMPROVE_EFFICIENCY_ENABLE
#endif


//#define UART_TX_EVENT_FIFO_EMPTY_ENABLE


//#define RICHARD

#ifdef RICHARD
//TX_MUTEX gUartTxMutex;

#define UART_TX_EVENT_FIFO_EMPTY		0x01

TX_EVENT_FLAGS_GROUP gUartTxEvent;
#endif


static char printfUartNum;

#if 0
//#define PRINTF_MAX_WAIT_TIME		(1000 / OS_MSEC_PER_TICK  + 1)		//1000ms
#define PRINTF_MAX_WAIT_TIME		( 500 / OS_MSEC_PER_TICK  + 1)		//500ms
#endif

static int fifoPutCallback( PRINTF_FIFO *fifo )
{
	int ret;
		
	ret = uart_startTx( printfUartNum, fifo );
	DBG_assert( ret );

	return ret;
}

static int fifoHalfEmptyCallback( PRINTF_FIFO *fifo )
{
	//unsigned int ret;

#if 0//def UART_TX_EVENT_FIFO_EMPTY_ENABLE
	//if set the event here, thread RTOS is ok, but free RTOS it isno't ok.
	UART_TX_EVENT_FIFO_EMPTY_SET;
#endif

	return TRUE;
}

#if 1
static int fifoFullCallback( PRINTF_FIFO *fifo )
{
	//unsigned int ret;
	unsigned long flag;

#ifdef UART_TX_EVENT_FIFO_EMPTY_ENABLE
	UART_TX_EVENT_FIFO_EMPTY_GET;
#endif

	return TRUE;
}
#endif


void printf_init( void )
{
	unsigned int ret;
	
	printfUartNum	=	PRINTF_UART_NUM;

#ifdef RICHARD
	ret = tx_event_flags_create( &gUartTxEvent, NULL );	
	DBG_Assert( TX_SUCCESS == ret );
#endif

	ptxfifo	=	&txFiFo;

#if 1
	printf_fifo_init( ptxfifo, txFifoBuffer, TX_FIFO_SIZE,  
			fifoPutCallback, NULL, NULL, fifoFullCallback, fifoHalfEmptyCallback, NULL );
#else
	printf_fifo_init( ptxfifo, txFifoBuffer, TX_FIFO_SIZE,  
			fifoPutCallback, NULL, NULL, NULL, fifoHalfEmptyCallback, NULL );
#endif

#ifdef UART_PRINTF_FIFO_ENABLE
	fifo_init ( &printf_fifo, txFifoBuffer, TX_FIFO_SIZE,TRUE);
#endif
}

//unsigned long uart2_event_wait_cnt = 0; //only for test

static int outputb( const char *buf, int size )
{
#ifndef UART_PRINTF_FIFO_ENABLE
	unsigned long len1, len2;
	int sz	=	size;
	char *pChar = (char *)buf;
	//static unsigned int count = 0;
	//DBG_Assert( sz > 0 );

	do
	{
#if 0//ndef IMPROVE_EFFICIENCY_ENABLE
		len1 = fifo_getEmptySpace( ptxfifo );
		/*count++;
		if (count = 1000)
		{
			len1 = 0;
		}*/
#else
		//TX_DISABLE;
		len1 = FiFo_GetEmptySpace( ptxfifo );
		//TX_RESTORE;
#endif

		//if( len1 == 0 )
		//if( (len1 <= 64) )
		if( (len1 <= 32) )
		//if( (len1 <= 4) )
		{
			//DBG_Assert(FALSE);

#if 1
			return 0;//
#else

#if 0
			if( ptxfifo->fullCallback != NULL )
			{
				int ret;

				//wait the "UART_TX_EVENT_FIFO_EMPTY" event in the fifoFullCallback
				ret = (*ptxfifo->fullCallback) ( ptxfifo );
				if( !ret )
				{
					return 0;
				}
			}
#else

#ifdef UART_TX_EVENT_FIFO_EMPTY_ENABLE
			//uart2_event_wait_cnt++;
			UART_TX_EVENT_FIFO_EMPTY_GET;
#endif

#endif

#endif
		}
		else
		{
			len2 = (len1 >= sz) ? sz : len1;
#ifndef IMPROVE_EFFICIENCY_ENABLE
			fifo_put( ptxfifo, (char*)buf, len2 );
#else
			FiFo_Put( ptxfifo, pChar, len2 );
#endif
			buf +=	len2;
			sz -= len2;
		}

	} while( sz > 0 );
	
	return size;

#else

	U32 len;
	//volatile UART_REGISTERS *pregs = (UART_REGISTERS *)UART2_BASE_ADDR;
	volatile UART_REGISTERS *pregs;

	if (printfUartNum == en_UART0)
	{
		pregs = (UART_REGISTERS *)UART0_BASE_ADDR;
	}
	else if (printfUartNum == en_UART1)
	{
		pregs = (UART_REGISTERS *)UART1_BASE_ADDR;
	}
	else
	{
		pregs = (UART_REGISTERS *)UART2_BASE_ADDR;
	}

	len = fifo_get_free_space (&printf_fifo);

#if 1
	if (len < size)
	{
		//missing some char???
		//asm("break 1,1");
		size = len;
	}
#else
	if (len < size)
	//if (len < size + 32)
	{
#ifdef UART_TX_EVENT_FIFO_EMPTY_ENABLE
		//uart2_event_wait_cnt++;
		UART_TX_EVENT_FIFO_EMPTY_GET;
#endif
	}
#endif

	fifo_put_data (&printf_fifo, buf, size);

	//TX_DISABLE;
	pregs->intEnable |= INT_TX_BUF_HALF_EMPTY; //enable interrupt
	//TX_RESTORE;

	return size;

#endif //UART_PRINTF_FIFO_ENABLE
}

int myputs( const char *str )
{
#if 1//ndef UART0_USED_FOR_APP_UI
	int	len;
	unsigned long ret;
	
	UART2_TX_MUTEX_LOCK;

	len = outputb( str, (int)strlen( (char *)str ) );

	UART2_TX_MUTEX_UNLOCK;

	return len;
#endif
}


int Uart_Tx_Send(char *buf, int size )
{
#if 0//def UART0_USED_FOR_APP_UI
	int	len;
	unsigned long ret;
	
	UART2_TX_MUTEX_LOCK;
	
	len = outputb(buf, size);

	UART2_TX_MUTEX_UNLOCK;

	return len;
#endif
}

/*
int Uart_Tx_Send1(char *buf)
{
#ifdef UART0_USED_FOR_APP_UI

#if 1
	int	len;
	unsigned long ret;
	int size;

	UART2_TX_MUTEX_LOCK;
	
	size = strlen(buf);
	len = outputb(buf, size);

	UART2_TX_MUTEX_UNLOCK;

	return len;

#else
	int len;
	volatile UART_REGISTERS *pregs	=	(UART_REGISTERS *)UART0_BASE_ADDR;

	len = 0;
	UART2_TX_MUTEX_LOCK;

	while (*buf != 0)
	{
		//while ( !(pregs->status & STAT_TX_BUF_EMPTY) ) ;
		while ( (pregs->status & STAT_TX_BUF_FULL) );
		{
			pregs->txBuf = *buf++;
			len ++;
		}
	}

	UART2_TX_MUTEX_UNLOCK;

	return len;
#endif

#endif
}*/

#define	MAX_NUM_DIGITS		10
static char numBuffer[MAX_NUM_DIGITS];

static char *num2str( char *buf, int maxbuflen, unsigned int num, int base, int sign, int upcase )
{
#define	LOWWERCASE_DIGITS	"0123456789abcdef"
#define	UPPERCASE_DIGITS	"0123456789ABCDEF"

	int nums	=	(int)num;
	char *digits	=	upcase ? UPPERCASE_DIGITS : LOWWERCASE_DIGITS;
	char *pstr;
	
	DBG_Assert( (sign && (base == 10 ) ) || !sign );
	DBG_Assert( (base == 10) || (base == 16) );

#if 0
	if (nums < 0)
	{
		DBG_Assert(FALSE);
	}
#endif

	if( sign && (nums < 0) )
	{
		*buf ++	=	'-';
		-- maxbuflen;
		num	=	-nums; 	// ?
	}
	
	nums	=	0;
	pstr	=	numBuffer + MAX_NUM_DIGITS;
	do
	{
		*(--pstr)	=	digits[num % base];
		num /=	base;
		nums ++;
	}	while( num > 0 );
	
	if( nums > maxbuflen )
	{
		nums = maxbuflen;
	}

	while( nums -- )
	{
		*buf ++	=	*pstr ++;
	}
	
	return buf;
}


#define	STR_PRT_UNKNOWN_FMT	"UNKNOWN format"
#define	STR_PRT_NULL		"<NULL>\0\0"

static int	mysprintf( char *buf, int maxbufSize, const char *format, va_list args )
{
	char *bufend	=	buf + maxbufSize;
	char *buffer	=	buf;
	
	char chr;

	char *tstr;
	int	tints;
	unsigned int tintu;
		
	while( *format )
	{
		while( (*format != '%') && *format )
		{
			*buf ++	=	*format ++;
			DBG_Assert( buf <= bufend );
			if( buf >= bufend )
			{
				return maxbufSize;
			}
		}

		if( !*format )
		{
			return (buf - buffer);
		}
		
		++format;
		chr	=	*format ++;	
		DBG_Assert( chr > 0 );
		
		switch( chr )
		{
			case '%' :
				*buf ++	=	'%';
				break;
			
			case 'c' :
				chr	=	(char)va_arg( args, int );
				*buf ++	=	chr;
				break;
					
			case 's' :
				tstr	=	va_arg( args, char * );
				if( !tstr )
				{
					tstr	=	STR_PRT_NULL;
				}
				while( *tstr && (buf < bufend) )
				{
					*buf ++	=	*tstr ++;
				}
				break;
				
			case 'S' :
				tstr	=	va_arg( args, char * );
				if( !tstr )
				{
					tstr	=	STR_PRT_NULL;
				}
				while( (*tstr || *(tstr + 1)) && (buf + 2 <= bufend) )
				{
					*buf ++	=	*tstr ++;
					*buf ++	=	*tstr ++;
				}
				
				if( buf + 2 > bufend )
				{
					return (buf - buffer);
				}
				break;
			
			case 'd' :
			case 'D' :
				tints	=	va_arg( args, int );	
				buf	=	num2str( buf, (bufend - buf), tints, 10, TRUE, FALSE );
				break;
			
			case 'u' :
			case 'U' :
				tintu	=	va_arg( args, int );
				buf	=	num2str( buf, (bufend - buf), tintu, 10, FALSE, FALSE );
				break;
			
			case 'x' :
				tintu	=	va_arg( args, int );
				buf	=	num2str( buf, (bufend - buf), tintu, 16, FALSE, FALSE );
				break;
				
			case 'X' :
				tintu	=	va_arg( args, int );
				buf	=	num2str( buf, (bufend - buf), tintu, 16, FALSE, TRUE );
				break;
			
			default:
				DBG_Assert(0);
				strcpy( buffer, STR_PRT_UNKNOWN_FMT);				
				return strlen( STR_PRT_UNKNOWN_FMT );
		}		

		if( buf >= bufend )
		{
			return maxbufSize;
		}
	}

	return (buf - buffer);
}

int	myprintf( const char *format, ... )
{
#if 1//ndef UART0_USED_FOR_APP_UI
	int len1, len2;
	va_list vargs;

	unsigned long ret;

	UART2_TX_MUTEX_LOCK;
	
	va_start( vargs, format );
	len1 = mysprintf( (char *)outBuffer, PRINTF_MAX_BUF, format, vargs );
	DBG_Assert( len1 <= PRINTF_MAX_BUF );
	va_end( vargs );
	
	len2 = outputb( outBuffer, len1 );
#if 0//ndef UART_PRINTF_FIFO_ENABLE
	DBG_Assert( len1 == len2 );
#endif

	UART2_TX_MUTEX_UNLOCK;

	return len2;
#endif
}

int	myprintf_for_usbdev( const char *format, ... )
{
#if 1//ndef UART0_USED_FOR_APP_UI
	return 0;
#else
	int len1, len2;
	va_list vargs;

	unsigned long ret;

	UART2_TX_MUTEX_LOCK;
	
	va_start( vargs, format );
	len1 = mysprintf( (char *)outBuffer, PRINTF_MAX_BUF, format, vargs );
	DBG_Assert( len1 <= PRINTF_MAX_BUF );
	va_end( vargs );
	
	len2 = outputb( outBuffer, len1 );
#if 0//ndef UART_PRINTF_FIFO_ENABLE
	DBG_Assert( len1 == len2 );
#endif

	UART2_TX_MUTEX_UNLOCK;

	return len2;
#endif
}
//jj+
int	myiprintf( const char *format, ... )
{
//	return;
#if 1//ndef UART0_USED_FOR_APP_UI
	int len1, len2;
	va_list vargs;

	unsigned long ret;

	UART2_TX_MUTEX_iLOCK;
	
	va_start( vargs, format );
	len1 = mysprintf( (char *)outBuffer, PRINTF_MAX_BUF, format, vargs );
	DBG_Assert( len1 <= PRINTF_MAX_BUF );
	va_end( vargs );
	
	len2 = outputb( outBuffer, len1 );
#if 0//ndef UART_PRINTF_FIFO_ENABLE
	DBG_Assert( len1 == len2 );
#endif

	UART2_TX_MUTEX_iUNLOCK;

	return len2;
#endif
}
int	myprintf_no_os( const char *format, ... )
{
#if 1//ndef UART0_USED_FOR_APP_UI
	int len1, len2;
	va_list vargs;

	unsigned long ret;

//	UART2_TX_MUTEX_LOCK;
	
	va_start( vargs, format );
	len1 = mysprintf( (char *)outBuffer, PRINTF_MAX_BUF, format, vargs );
	DBG_Assert( len1 <= PRINTF_MAX_BUF );
	va_end( vargs );
	
	len2 = outputb( outBuffer, len1 );
#if 0//ndef UART_PRINTF_FIFO_ENABLE
	DBG_Assert( len1 == len2 );
#endif

//	UART2_TX_MUTEX_UNLOCK;

	return len2;
#endif
}


#ifdef BT_HCI_ENABLE
//int bt_printf( const char *format, ... ) __INTERNAL_RAM_TEXT;

int	bt_printf( const char *format, ... )
{
#if 1
	return 0; //no need bt debug info
#else
#if 1//ndef UART0_USED_FOR_APP_UI
	int len1, len2;
	va_list vargs;

	unsigned long ret;

	UART2_TX_MUTEX_LOCK;
	
	va_start( vargs, format );
	len1 = mysprintf( (char *)outBuffer, PRINTF_MAX_BUF, format, vargs );
	DBG_Assert( len1 <= PRINTF_MAX_BUF );
	va_end( vargs );
	
	len2 = outputb( outBuffer, len1 );
#if 0//ndef UART_PRINTF_FIFO_ENABLE
	DBG_Assert( len1 == len2 );
#endif

	UART2_TX_MUTEX_UNLOCK;

	return len2;
#endif

#endif
}
#endif