#include "cc_config.h"
#include "cc_type.h"
#include "cc_def.h"
#include "cc_private.h"

//#include <string.h>
#include <stdarg.h>

#if 0
__STRING__() {}
#endif

#if USE_ADVANCED_KSX_TO_UNICODE_TABLE
#include "ksx_uni_table2.h"
#else

#if USE_INNER_KSX_TO_UNICODE_TABLE
#include "cc_ksx_unicode_table.h"
#else
//UINT16 *p_ck2uk_table=DST_cktouk;
extern UINT16 p_ck2uk_table[];
#endif

#endif


int DCCUtil_UStrLen(UINT16 *str)
{
	int i;
	
	for(i=0; str[i]; i++);
	
	return i;
}

#if USE_ADVANCED_KSX_TO_UNICODE_TABLE

UINT16 DCCUtil_Ksx1001toUnicode(UINT16 code)
{
	UINT8 byte1=(code>>8), byte2=(code&0xff);
	int tab_idx = ((int)byte1 - 0x00a1) * 94 + (int)byte2 - 0x00a1;
	long code_ucs2;
	
	if(code<0xa1a0 || code>0xfdff) return code;
	
	if(code==0xa2e6) return 0x20ac;
	else if(code==0xa1a1) return 0x20;
	//else if(code==0xa3dc) return 0x209a;
	else if(code==0xa2a6) return 0x7e;
	else if(code==0xa2e7) return 0x00ae;
	else if(code>=0xa3a0 && code<0xa4a0) return code-0xa3a0+0x20;
	else if(code>=0xa4a0 && code<0xa5a0) return code-0xa4a0+0x2f80+0x1b0;
	else if (tab_idx >= 0 && tab_idx < ksc5601max) {
		code_ucs2 = tabksc5601[tab_idx];
		if (code_ucs2 != -1) return code_ucs2;
	}
	
	return 0x20; //if not exist, then return 0x20(blank)
}

#else

UINT16 DCCUtil_Ksx1001toUnicode(UINT16 code)
{
	UINT16 ret_code;
	
	if(!p_ck2uk_table) return code;
	
	if(code<0xa1a0 || code>0xfdff) return code;
	
	if(code>=0xa3a0 && code<=0xa3fe) {
		ret_code=code-0xa380;
	}
	else {
		code |= 0x8080;
		
		if(code>=0xb0a1 && code<=0xc8fe) {
			code-=45217;
			code=code/256*94 + code%256;
			ret_code=p_ck2uk_table[code];
		}
		else if(code==0xa1a1) //space
			ret_code=0x20;
		else if(code==0xa3dc) //back slash -> won
			ret_code=0x20a9;
		else if(code>=0xa3a0 && code<=0xa3fe)
			ret_code=code-0xa380;
		else if(code==0xa2a6)
			ret_code=0x7e;
		else
			ret_code=0x20;//Áö¿øÇÏÁö ¾Ê´Â ÄÚµå´Â °ø¹é ó¸®//ret_code=0x25af; //Áö¿øÇÏÁö ¾Ê´Â codeÀÎ °æ¿ì ¼¼¿î Á÷»ç°¢Çü
	}
	
	return ret_code;
}

#endif


#if 0
__DEBUG__() {}
#endif



#define MAX_NAME_LEN 16
#define MAX_DBG_ITEM 64

static struct {
	char name[MAX_NAME_LEN];
	BOOL is_on;
} p_dbg_info[MAX_DBG_ITEM]=
{ 
	{"noti", FALSE},
	{"warn", TRUE},
	{"error", TRUE},
	{"ud", FALSE},
	{"dmx708", FALSE},
	{"parse708", FALSE},
	{"parse708ex", FALSE},
	{"win_ch", FALSE},
	{"win_chex", FALSE},
	{"win_rect", FALSE},
	{"win_line", FALSE},
	{"spl", FALSE},
	{"dfx", FALSE},
	{"708data", FALSE},
	//{"ddi_box", TRUE},
	//{"ddi_ch", TRUE},
};

static int p_dbg_idx=14;
static UINT32 p_ms_debug_off;
static BOOL p_is_dbg_on=TRUE;


void DCCUtil_DbgPrint(char *pname, char *fmt, ...)
{
	int i;
	
	if(!p_is_dbg_on) return;
	
	for(i=0; i<p_dbg_idx; i++) {
		if(strcmp(pname, p_dbg_info[i].name)==0) {
			if(!p_dbg_info[i].is_on) return;
				
			break;
		}
	}
	
	if(i==p_dbg_idx) { /* ãÁö ¸øÇÔ, µî·Ï */
		if(p_dbg_idx<MAX_DBG_ITEM-1) {
			strcpy(p_dbg_info[p_dbg_idx++].name, pname);
		}
		else {
			DHL_OS_Printf("!! dbg item is over MAX_DBG_ITEM(%d)\n", MAX_DBG_ITEM);
		}
		
		return;
	}
	
	if(DCCDDI_GetCurMs()-p_ms_debug_off<3000) return;
		/* 3ÃÊ Á¤µµ ½Ã°£À» ¹ø´Ù */
	
	if(1) {
		char buf[512];
		va_list v;
		sprintf(buf, "[CC:%05d][%8s] ", DCCDDI_GetCurMs()/10, pname);
		
		va_start(v, fmt);
#if SUPPORT_WINDOWS
		_vsnprintf(buf+strlen(buf), 512-strlen(buf), fmt, v);
#else
		vsnprintf(buf+strlen(buf), 512-strlen(buf), fmt, v);
#endif
		va_end(v);

		DHL_OS_Printf(buf);

	}
}

void DCCUtil_ShowDbgItem()
{
	int i;
	
	p_ms_debug_off=DCCDDI_GetCurMs();
	
	DHL_OS_Printf("Debug Info.\n");
	DHL_OS_Printf("--------------------------------------------------\n");
	DHL_OS_Printf("id   on     name\n");
	DHL_OS_Printf("--------------------------------------------------\n");
	for(i=0; i<p_dbg_idx; i++) {
		DHL_OS_Printf("%2d : %s | %s\n", i, p_dbg_info[i].is_on?"On ":"Off", p_dbg_info[i].name);
	}
	
	DHL_OS_Printf("--------------------------------------------------\n");
	
}


void DCCUtil_SetDbgOn(char *pname, BOOL is_on)
{
	int i;
	
	for(i=0; i<p_dbg_idx; i++) {
		if(strcmp(pname, p_dbg_info[i].name)==0) {
			p_dbg_info[i].is_on=is_on;
			return;
		}
	}
	
	if(p_dbg_idx<MAX_DBG_ITEM-1) {
		strcpy(p_dbg_info[p_dbg_idx].name, pname);
		p_dbg_info[p_dbg_idx].is_on=is_on;
		p_dbg_idx++;
	}
}


void DCCUtil_ToggleDbgOn(char *pname)
{
	int i;
	
	for(i=0; i<p_dbg_idx; i++) {
		if(strcmp(pname, p_dbg_info[i].name)==0) {
			p_dbg_info[i].is_on=p_dbg_info[i].is_on?FALSE:TRUE;
			return;
		}
	}
}


void DCCUtil_SetDbgOnByIdx(int idx, BOOL is_on)
{
	if(idx>=p_dbg_idx) {
		DHL_OS_Printf("!! bad idx num\n");
		return;
	}
	
	p_dbg_info[idx].is_on=is_on;
}


void DCCUtil_ToggleDbgOnByIdx(int idx)
{
	if(idx>=p_dbg_idx) {
		DHL_OS_Printf("!! bad idx num\n");
		return;
	}
	
	p_dbg_info[idx].is_on=p_dbg_info[idx].is_on?FALSE:TRUE;
}

void cda(char *pname) /* cc debug active */
{
	DCCUtil_SetDbgOn(pname, TRUE);
}

void cdi(char *pname) /* cc debug inactive */
{
	DCCUtil_SetDbgOn(pname, FALSE);
}

void csd() /* cc show debug */
{
	DCCUtil_ShowDbgItem();
}

void cdai(int idx) /* cc debug active by index */
{
	DCCUtil_SetDbgOnByIdx(idx, TRUE);
}

void cdii(int idx) /* cc debug inactive by index */
{
	DCCUtil_SetDbgOnByIdx(idx, FALSE);
}

void ctn(char *pname) /* cc toggle by name */
{
	DCCUtil_ToggleDbgOn(pname);
}

void cti(int idx) /* cc toggle by index */
{
	DCCUtil_ToggleDbgOnByIdx(idx);
}

void cdo()
{
	p_is_dbg_on=p_is_dbg_on?FALSE:TRUE;
}

#if 0
__BIT_BUFFER__() {}
#endif

#define MAX_SIZE_BIT_BUF (256+3)

static UINT8 p_regBitBuf[MAX_SIZE_BIT_BUF];//neverdai 070522.
static UINT16 p_regBitBufSize, p_regBitBufIdx;

static void p_attach_end_marker()//neverdai 070522.
{
	p_regBitBuf[p_regBitBufSize/8]=0x0;
	p_regBitBuf[p_regBitBufSize/8+1]=0x0;
	p_regBitBuf[p_regBitBufSize/8+2]=0x1;
	p_regBitBufSize+=24;
}


void DCCUtil_InitBitBuf(UINT8 *pdata, int size)
{
	if(!pdata || size==0) {
		p_regBitBufSize=0;
		return;
	}

	if(size>=MAX_SIZE_BIT_BUF) {
		CCPRINT("warn", "!! Error..size is over 256\n");
#if 0
		p_regBitBufSize=0;
		return;
#else
		size=MAX_SIZE_BIT_BUF;
#endif
	}
		
	memcpy(p_regBitBuf, pdata, size);
	p_regBitBufSize=size<<3;//p_regBitBufSize*8;
	p_regBitBufIdx=0;
	p_attach_end_marker();
}


UINT32 DCCUtil_NextBits(UINT8 size)
{
	int i;
	UINT32 retVal;
	UINT8 temp;

	//bit under flow check
	if(p_regBitBufIdx+size>p_regBitBufSize) {
		return 0;
	}
	
	temp=p_regBitBuf[p_regBitBufIdx/8];
	
	for(i=p_regBitBufIdx, retVal=0 ;i<p_regBitBufIdx+size;) {
		
		retVal=(retVal<<1)|((temp>>(7-i%8))&0x1);
		
		if(++i%8==0)
			temp=p_regBitBuf[i/8];
	}
	
	return retVal;	
}
		

UINT32 DCCUtil_GetBits(UINT8 size)
{
	int retValue;
	
	//bit under flow check	
	if(p_regBitBufIdx+size>p_regBitBufSize) {
		return 0;
	}
	
	retValue=DCCUtil_NextBits(size);
	
	p_regBitBufIdx+=size;
	
	return retValue;
}

void DCCUtil_UngetBits(UINT32 size, UINT32 data)
{
	//ÇÊ¿ä¾øÀ» µí.
}

//GetBits³ª NextBits Àü¿¡ bit underflow check.
int DCCUtil_CheckBits(UINT8 size)
{
	if(p_regBitBufIdx+size>p_regBitBufSize) {
		return -1;
	}
	return 0;	//success
}