/**
	@file
		DHL_SYS_Platform.c

	@brief
		

	이 모듈에 대한 간단한 설명.. 
	ex: AudioVideo decoding/capture/output implementation

	Copyright 2006~2010 Digital STREAM Technology, Inc.
	All Rights Reserved
*/


#include "DHL_OSAL.h"
#include "DHL_DBG.h"



//#include <stdio.h>
////#include <string.h> // for memcpy

/*
	모든 헤더 파일을 포함하지는 않으며, compile time을 줄이기 위해
	각 모듈은 필요한 만큼의 헤더를 선언하도록 함.
*/



/*
	DHL 디버그 모듈 이름 정의 룰 참고:

	DHL 모듈들은 모두 * 로 시작.
	API는 대문자, Platform 및 기타는 소문자 사용.

	디폴트 레벨은 0으로 설정한다. (0: 에러 메시지만 출력)
	
	
*/

//DHL_MODULE("*MMM", 0);



#if COMMENT
____Config____(){}
#endif

/*
	이 모듈 내부에서 사용되는 각종 configuration 정의.
*/


/* #define SUPPORT_FAST_SWITCHING_OPTIMIZATION 1 */
/* #define FUNC_MONITOR_TIMER_ID TIMER_ID_FUNC_MONITOR */



#if COMMENT
____Types____(){}
#endif

/*
	이 모듈 내부에서 사용되는 structure 및 enumerations.
*/



#if COMMENT
____Variables____(){}
#endif

/*
	global로 적용되는 variable 정의.
	각 function 별로 특수한 용도의 variable은 각 functionX block 에서 정의 가능.
*/






#if COMMENT
_____DbgPrint_____(){}
#endif


#define DHL_DBG_USE_MUTEX 1
	// OS_LockTask 과 같은 상태에서도 debug print를 하려고 한다면
	// mutex를 사용하지 않아야 한다.
	// 일단 caller가 유의해서 사용하기로 하고 mutex 사용함.


//-------------------------------------------------------------------
// debug log function.
// special prefix is inserted at the head of line,
//   not to be confused with other UART message..
//

// 디버그 메시지 표시되는 예: full option
//
//   [APP] {tCmdExecute,130} 0320 Channel Up
//   [DMC] {tDmc,105} 0320 Dmc_ChangeChannelUp(uid 3)
//   SetTuner, AIR, 8VSB                         <--- driver에서 출력하는 메시지
//   [DMC] {tDmc,105} 0323   Channel change end
//   [Timer] {tTimer, 200} 00324 Timer started, tid 1 period 3
//   [APP] {AppGUI,120} 0324 channel 
//   [EPG] {tEpgTask,120} 0326 epg start..
//   
// 
// 각 모듈별로 PREFIX 이름을 변경해서 사용. 
// 글자 수 제한은 없으나 3~5자로 맞춰주면 좋겠음.
//
// 예)  [iLink]  [EPG]  [PNR]  등등..



BOOL g_dhl_useMessage = TRUE;
	// 양산 시점에는 이 변수를 FALSE로 하고 출하하면 지저분한 메세지를 없앨수 있음.
	// 문제가 발생시 UART를 통해서 이 변수를 ON 시킨 후 디버깅을 할 수 있다.

BOOL g_dhl_usePrintPrefix = TRUE;
	// TRUE이면 log message 앞에 [TAG]를 추가.
	
BOOL g_dhl_printTimeTick = TRUE;
	// TRUE이면 log message 앞에 time tag를 추가.
	// time tag는 메시지들 간의 시간 관계를 조사할 때 편리함. 시간 단위는 아래 참조.
	
BOOL g_dhl_printTaskInfo = FALSE;
	// TRUE이면 task ID를 같이 표시.
	
BOOL g_dhl_useOsalPrintf = FALSE;
	// TRUE이면 DHL_OS_Printf 사용.

DHL_OS_SEMA_ID g_dhl_printSema4;
	// Print 함수 내부적으로 사용하는 Sema4
	
int g_dhl_sema4InitFailCount;
	// Semaphore 생성시 에러 발생 횟수 카운터
	// 이 카운터 값을 관리하는 이유는 시스템 리소스 등의 이유로 Semaphore 생성이 실패할 경우
	// 매 Print call 마다 Semaphore 생성을 재시도 하게 되면 시스템에 악영향을 줄 수 있기 때문.
	// 일정 횟수 이상 실패한다면 Semaphore 없이 그냥 진행한다.
	//

BOOL g_dhl_flushBufferAlways;
	// true 이면 매 printf 마다 console buffer를 flush 한다.
	// 이 설정을 변경하는 API를 이용.

static int timetick(void)
{
	// timing information.
	// should not greater than 9999.
	
#if 1
	return DHL_OS_GetMsCount() % 10000;
	
#elif 1
	// 10 millisec unit. uCOS specific. os ticks per second is 200.
	// to release cpu burden, i used hard-coded value.
	return ((OS_GetTickCount() / 2) % 10000);

#elif 1
	return ((OS_GetTickCount()*100/OS_GetTicksPerSecond()) % 10000);
	// 
	// 출력될 timetick의 단위는 0.1초로 함.
	// UINT32 type이므로 x10에서 overflow가 날 수 있는데 별 문제 안됨.
	//

#elif 1
	return (dhl_sys_get_ms_tick() % 10000);
	
#elif 1
	return ((Demux_GetSTC()/90) % 10000);
	// 단위는 millisec

#endif

}


#if DHL_DBG_USE_MUTEX
static void p_dbg_create_mutex()
{
	DHL_OS_SEMA_ID mysema4 = (DHL_OS_SEMA_ID)0;

	if (g_dhl_printSema4 == (DHL_OS_SEMA_ID)0 && g_dhl_sema4InitFailCount < 5)  // create sema4
	{
		mysema4 = DHL_OS_CreateMutexSemaphore("DhlPrintf");

		if (mysema4 == (DHL_OS_SEMA_ID)0) {
			DHL_OS_Printf("!! DhlPrintf Sema4 creation failed.\n");
			g_dhl_sema4InitFailCount++;
		}
		else {
			// Semaphore 생성 성공.  이제 생성된 sema4를 g_dhl_printSema4에 안전하게 assign한다.
			
			if (1)
			{
				UINT32 mask = DHL_OS_DisableInterrupts();
				if (g_dhl_printSema4 == 0) {
					// OS_LockTask 된 상태에서 g_dhl_printSema4를 초기화 한다.
					g_dhl_printSema4 = mysema4;
					mysema4 = (DHL_OS_SEMA_ID)0;
				}
				DHL_OS_RestoreInterrupts(mask);
			}
			
			if (mysema4) {  // 이미 g_dhl_printSema4가 다른 태스크에 의해 생성이 된 경우임.
				DHL_OS_Printf("!! Simultaneous DbgPrint Sema4 Creation detected %x. Safe release ours %x\n", 
							(UINT32)g_dhl_printSema4, (UINT32)mysema4);
				DHL_OS_DeleteSemaphore(mysema4);
				mysema4 = (DHL_OS_SEMA_ID)0;
			}
			else
				DHL_OS_Printf("DhlPrintf Sema4 created\n");
		}
	}
}
#endif // DHL_DBG_USE_MUTEX



/* DbgPrintFlag options
*/

#define DHL_DPF_TASKNAME 0x1
#define DHL_DPF_TASKPRIO 0x2
#define DHL_DPF_TIMETICK 0x4

#define DHL_DPF_STDERR 0x100  // stderr 에 출력하도록 함.
#define DHL_DPF_FLUSH  0x200  // 매 printf 마다 flush를 수행.


int dhl_dbg_print_base(char *prefix, UINT32 flags, char *format, va_list ap)
{
	int n = 0;
	int len_prefix, len_taskinfo, len_timetick;
	
    char *p;
	
#if DHL_DBG_USE_MUTEX	
	static char s_buf[4096]; // static buffer
#endif
	char l_buf[1024]; // local buffer
	char *buf;

	static BOOL s_bFirstColumn = TRUE;
	
	char ticks[10];

#if DHL_DBG_USE_MUTEX	
	static char taskinfo[128]; // task name is actually unlimited string..
		// anyway, we can safely use static array because this function is protected by semaphore.
#endif
	
	// for using static buffer, i blocked this function with sema4.
	BOOL bSemTakenHere = FALSE;

	DHL_OS_TASK_INFO info;
	DHL_RESULT dhr;

	BOOL bTaskName = (flags & DHL_DPF_TASKNAME) ? 1 : 0;
	BOOL bTaskPrio = (flags & DHL_DPF_TASKPRIO) ? 1 : 0;
	BOOL bTime     = (flags & DHL_DPF_TIMETICK) ? 1 : 0;
	
	
	if (!g_dhl_useMessage) return 0;

	if (format == NULL)
		return 0;
	
	if (prefix == NULL) prefix = "";
	len_prefix = strlen(prefix);

#if DHL_DBG_USE_MUTEX
	if (g_dhl_printSema4 == (DHL_OS_SEMA_ID)0)
		p_dbg_create_mutex();

	// 현재 os scheduler가 lock 상태라면 mutex를 lock이 deadlock을 유발할 수 있음.
	if (DHL_OS_GetIntState()) {
		DHL_OS_Printf("~"); buf = l_buf;
	}
	#if 0 // 새로운 DHL OSAL 에서는 task lock API가 제거되었음.
	else if (osi_in_tasklock(NULL)) {
		DHL_OS_Printf("^"); buf = l_buf;
	}
	#endif
	else  {
		buf = s_buf;
		if (g_dhl_printSema4) {
			DHL_OS_TakeSemaphore(g_dhl_printSema4, DHL_TIMEOUT_FOREVER);
			bSemTakenHere = TRUE;
		}
	}
#else
	buf = l_buf; // use local buffer. then no mutex required.
#endif
   
    if (strlen(format) > 512)
    	DHL_OS_Printf("!! Warning! too long msg. may be overflow..\n");

	p = buf;
	
	// var list를 buffer에 expand 시킨다.
	if (format)
		n = vsnprintf(p, sizeof(p), format, ap);
	else
		strcpy(buf, "NULL");

	if (g_dhl_usePrintPrefix) 
	{
		// debug message중의 LF (LineFeed) 다음에 "[Prefix] {Task,Priority} time_tag " 를 삽입.
		//
		// 현재 커서가 column zero에 있을 경우에만 tag를 삽입한다.
		//
		int safty_limit = 0;

		p = buf;
		
		if (s_bFirstColumn) 
		{
	#if DHL_DBG_USE_MUTEX		
			if (bTaskName || bTaskPrio) {
				dhr = DHL_OS_GetTaskInfo(DHL_OS_GetTaskID(), &info);
				if (dhr != DHL_OK)
					snprintf(taskinfo, sizeof(taskinfo), "{? 0x%x} ", dhr);
				else if (bTaskName && bTaskPrio)
					snprintf(taskinfo, sizeof(taskinfo), "{%s,%2x} ", info.name, info.priority);
				else if (bTaskName)
					snprintf(taskinfo, sizeof(taskinfo), "{%s} ", info.name);
				else
					snprintf(taskinfo, sizeof(taskinfo),"{p%2x} ", info.priority);
					
				len_taskinfo = strlen(taskinfo);
			}
			else 
				len_taskinfo = 0;
	#endif
			
			if (bTime) {
				snprintf(ticks, 10, "%04d ", timetick());
				len_timetick = 5;
			}
			else
				len_timetick = 0;
			
			if (len_prefix + len_taskinfo + len_timetick > 0)
				memmove(p + len_prefix + len_taskinfo + len_timetick, p, strlen(p)+1); // 공간확보. prefix + taskinfo + time_tick
			
			if (len_prefix)
				memcpy(p, prefix, len_prefix);                          // prefix 삽입.

	#if DHL_DBG_USE_MUTEX		
			if (len_taskinfo)
				memcpy(p+len_prefix, taskinfo, len_taskinfo);           // taskinfo 삽입.
	#endif
	
			if (len_timetick)
				memcpy(p+len_prefix+len_taskinfo, ticks, len_timetick);    // time_tick 삽입.
		}
		
		while (1) {
			p = strchr(p, 0xA);  // LF 코드를 찾음.
			if (p == NULL) {
				break;
			}
			if (*++p == 0) { // 이 LF가 마지막 문자라면 여기서 종료.
				break;
			}

	#if DHL_DBG_USE_MUTEX		
			if (bTaskName || bTaskPrio) {
				dhr = DHL_OS_GetTaskInfo(DHL_OS_GetTaskID(), &info);
				if (dhr != DHL_OK)
					snprintf(taskinfo, sizeof(taskinfo), "{? 0x%x} ", dhr);
				else if (bTaskName && bTaskPrio)
					snprintf(taskinfo, sizeof(taskinfo), "{%s,%2x} ", info.name, info.priority);
				else if (bTaskName)
					snprintf(taskinfo, sizeof(taskinfo), "{%s} ", info.name);
				else
					snprintf(taskinfo, sizeof(taskinfo), "{p%2x} ", info.priority);
					
				len_taskinfo = strlen(taskinfo);
			}
			else 
				len_taskinfo = 0;
	#endif // DHL_DBG_USE_MUTEX		
			
			if (bTime) {
				sprintf(ticks, "%04d ", timetick());
				len_timetick = 5;
			}
			else
				len_timetick = 0;
			
			if (len_prefix + len_taskinfo + len_timetick > 0)
				memmove(p + len_prefix + len_taskinfo + len_timetick, p, strlen(p)+1); // 공간확보. prefix + taskinfo + time_tick
			
			if (len_prefix)
				memcpy(p, prefix, len_prefix);                          // prefix 삽입.

	#if DHL_DBG_USE_MUTEX		
			if (len_taskinfo)
				memcpy(p+len_prefix, taskinfo, len_taskinfo);           // taskinfo 삽입.
	#endif
	
			if (len_timetick)
				memcpy(p+len_prefix+len_taskinfo, ticks, len_timetick);    // time_tick 삽입.


			if (safty_limit++ > 10) {
				DHL_OS_Printf("!! Warning! too many LFs. skip remainings.\n");
				break;
			}
		}
		p = buf;
	}

	// now print it!
	
	if (flags & DHL_DPF_FLUSH) {
		fprintf(1/*stderr*/, p);
	}
	else {
		DHL_OS_Printf(p);
		// in this case, message print may be deferred at arbitrary time.
	}

	if (flags & DHL_DPF_FLUSH)
		; //dhl_dbg_flush_console();


	if (p[strlen(p)-1] == 0xA) // 마지막 글자가 LF라면 커서는 이제 맨 처음으로 이동햇음.
		s_bFirstColumn = TRUE;
	else
		s_bFirstColumn = FALSE;
	
	if (bSemTakenHere) // 이 함수에서 take했던 경우에만 Sem release를 한다.
		DHL_OS_GiveSemaphore(g_dhl_printSema4);

	return n;
}

int dhl_dbg_print(char *prefix, char *format, va_list ap)
{
	return dhl_dbg_print_base(prefix, DHL_DPF_TIMETICK, format, ap);
}




#if COMMENT
____Level_Print____(){}
#endif



/*
	usage:
		DHL_DBG("this_module", 1);  
			// eDBG_MODULE_LVL_Warn. means that Error(0) and Warn(1) level message is allowed to print.

		dprint(0, "this is error level..\n"); // this is Error level. printed.
		dprint(1, "this is warn level..\n");  // this is Warn level. printed.
		dprint(2, "this is info level..\n");  // this is Info level. NOT printed.

		if (dprintable(3))  // memdump msg is Verbose level. NOT printed.
			memdump(...);

*/

#define MAX_MODULE_NUM 128

static struct {
	char name[16];
	int level;
} p_module_level_table[MAX_MODULE_NUM];

static int p_module_level_idx;


void DHL_DBG_SetModuleLevel(char *module_name, int level)
{
	int i;
	if (!module_name) return;
	if (level < eDBG_MODULE_LVL_Silent) {
		DHL_OS_Printf("!! invalid dbg module level %d\n", level);
		return;
	}
	
	for(i=0; i<p_module_level_idx; i++) {
		if(strcmp(module_name, p_module_level_table[i].name)==0) {
			p_module_level_table[i].level=level;
			break;
		}
	}
	if (i<p_module_level_idx) {
		DHL_OS_Printf("dbg module '%s' level changed to %d\n", module_name, level);
		return;
	}

	// allocate new dbg module entry
	if(p_module_level_idx>=MAX_MODULE_NUM) return;
	
	strncpy(p_module_level_table[p_module_level_idx].name,module_name,15);
	p_module_level_table[p_module_level_idx].name[15] = 0;
	p_module_level_table[p_module_level_idx].level=level;
	p_module_level_idx++;
	
	DHL_OS_Printf("dbg module '%s' added, level %d. total %d modules\n", 
			module_name, level, p_module_level_idx);

}


int DHL_DBG_GetModuleLevel(char *module_name)
{
	int i;
	if (!module_name) return eDBG_MODULE_LVL_Unknown;
	
	for(i=0; i<p_module_level_idx; i++) {
		if(strcmp(module_name, p_module_level_table[i].name)==0) {
			return p_module_level_table[i].level;
		}
	}
	return eDBG_MODULE_LVL_Unknown;
}

/*
	check that module is registerred and add with new level.
	if already registerred, skip.

	어짜피 level print 에서 체크하게 되므로, 
	한번의 체크로 init 과 level check를 같이 수행하는 함수가 더 효율적임.
	이 함수에서 level을 알아낸 후 미리 체크하고 LevelPrint가 아니라 
	Print 함수를 사용할 수도 있는 방법 제공.
*/
int DHL_DBG_CheckAndInitModuleLevel(char *module_name, int default_level)
{
	//tDBG_MODULE_LVL level;
	int level;
	if ((level = DHL_DBG_GetModuleLevel(module_name)) == eDBG_MODULE_LVL_Unknown) {
		DHL_DBG_SetModuleLevel(module_name, default_level);
		level = default_level;
	}
	return (int)level;
}

void DHL_DBG_PrintModuleLevel(const char *substr)
{
	int i;
	int n_modules = 0;
	const char *border;
	
	if (substr && substr[0]) 
		DHL_OS_Printf("modules that contains '%s'\n", substr);

	border = "===================================\n";
	DHL_OS_Printf(border);
	
	for(i=0; i<p_module_level_idx; i++) {
		if (substr && substr[0] && 
			strstr(p_module_level_table[i].name, substr) == NULL) 
			continue;
		DHL_OS_Printf(" (%2d) %-10s : %d\n", i,
			p_module_level_table[i].name, p_module_level_table[i].level);
		n_modules++;
	}
	DHL_OS_Printf(border); 
	DHL_OS_Printf(" %d modules \n", n_modules);
}



int DHL_DBG_LevelPrint(char *prefix, int level, char *format, va_list ap)
{
	int n;
	int module_level=eDBG_MODULE_LVL_Unknown;
	char prefix2[48];
	DHL_OS_TASK_INFO tinfo;	
	DHL_RESULT dhr;
	
	//검색
	for(n=0; n<p_module_level_idx; n++) {
		if(strcmp(prefix, p_module_level_table[n].name)==0) {
			module_level=p_module_level_table[n].level;
			break;
		}
	}
	if (module_level == eDBG_MODULE_LVL_Unknown) {
		DHL_OS_Printf("!! unknown module '%s'!!\n", prefix);
		return 0;
	}

	if(module_level < level) {
		//DHL_OS_Printf("module '%s', mlv %d > lvl %d, msg '%s' skipped\n", prefix, level, format);
		return 0;
	}

	dhr = DHL_OS_GetTaskInfo(DHL_OS_GetTaskID(), &tinfo);
	if (dhr)
		sprintf(prefix2, "[%s ?? 0x%x] ", prefix, dhr);
	else
		sprintf(prefix2, "[%s %d %s] ", prefix, tinfo.priority, tinfo.name);
	
	return dhl_dbg_print(prefix2, format, ap);
}

int DHL_DBG_KeyPrint(char *prefix, char *format, va_list ap)
{
	DHL_OS_Printf("|%s| not implemented...\n", __FUNCTION__);
	
	return 0;
}



/* end of file */