#include "MMI_include.h"


//





/*********************************************************************************
 *                                      函数实现
 *********************************************************************************/

//sscanf() - 从一个字符串中读进与指定格式相符的数据
int ahex_to_int(const char* hex_str)
{
   int r = 0;
   if(hex_str)
     sscanf(hex_str,"%x",&r);
   return r;
}

void gbcp_utf8_to_unicode(char *pUtf8, U16 *pUnicode, U16 dest_size)
{
    memset(pUnicode, 0, dest_size);
#ifndef MMI_ON_WIN32
	mmi_chset_utf8_to_ucs2_string((kal_uint8 *)pUnicode, dest_size, (kal_uint8 *)pUtf8);
#else
	MultiByteToWideChar(CP_UTF8, 0, pUtf8, dest_size, (U16*)pUnicode, dest_size/2);
#endif 
}
void gbcp_gbk_to_unicode(char* pGBK, U16 *pUnicode, U16 dest_size)
{
#if 0
    memset(pUnicode, 0, dest_size);
#ifndef MMI_ON_WIN32
	mmi_chset_text_to_ucs2_str((kal_uint8*)pUnicode, dest_size, (kal_uint8*)pGBK, 1);
#else
	MultiByteToWideChar(CP_ACP, 0, pGBK, dest_size, (U16*)pUnicode, dest_size/2);
#endif 
#else
	GBC_convert_gbk_to_unicode(pGBK, pUnicode, dest_size);
#endif
}
void gbcp_unicode_to_gbk(U16 *pUnicode, char* pGBK, U16 dest_size)
{
	GBC_convert_unicode_to_ansii((const kal_uint8 *)pUnicode, (U8 *)pGBK, dest_size);
}

void gbcp_unicode_to_utf8(S8 *pUnicode, PS8 pUtf, U16 dest_size)
{
	mmi_chset_ucs2_to_utf8_string((kal_uint8 *)pUtf, (kal_int32) dest_size, (kal_uint8 *)pUnicode);
}

void gbcp_set_color(color* color, U8 r, U8 g, U8 b)
{
	color->r = r;
	color->g = g;
	color->b = b;
	color->alpha = 100;
}

void gbcp_set_medium_font(void)
{
	stFontAttribute font_type = MMI_medium_font;
    gui_set_font(&font_type);
}

void gbcp_print_text(S16 x, S16 y, char* pText, color r, BOOL bUTF8Encode)
{
	char buffer[80]={0};
	
    if(bUTF8Encode)
        gbcp_utf8_to_unicode(pText, (U16*)buffer, sizeof(buffer));
    else
	    gbcp_gbk_to_unicode(pText, (U16*)buffer, sizeof(buffer));
	gbcp_set_medium_font();
    gui_set_text_color(r);	
	//gui_print_truncated_text(x, y, width, (UI_string_type)czShowTextBuffer);
	gui_move_text_cursor(x, y);
    gui_print_text((UI_string_type)buffer);
}
void gbcp_print_w_text(S16 x, S16 y,  S16 width, char* pText, color r)
{
	gui_set_text_color(r);
	gui_move_text_cursor(x, y);
    gui_print_text((UI_string_type)pText);
}
//打印带边框粗体字
void gbcp_print_bord_text(S16 x, S16 y, char* pText, color c)
{
    //(UI_COLOR_LIGHT_GREY);
    color OUT_COLOR = {0,0,128,100};//{178,0,31,100};
    char  wbuf[80];

    gbcp_gbk_to_unicode(pText, (U16*)wbuf, 80);
	gbcp_set_medium_font();
	gui_set_text_color(c);
	gui_set_text_border_color(OUT_COLOR);
	//使用gui_系列函数接口,需要计算字体的宽度
	gui_print_truncated_borderd_text(x, y, UI_device_width-20, (U16*)wbuf);
}

void gbcp_print_prompt_text(char* pText, int y)
{
	color localcolor;
	int   nFontHeight = gui_get_string_height(L"字串");	
	//int   nFontHeight = 20;

	gbcp_set_color(&localcolor, 255, 255, 255);
	gui_fill_rectangle(0,y,UI_device_width - 1,y+nFontHeight,localcolor);	
	gbcp_set_color(&localcolor, 178 ,0 ,31 );
	gbcp_print_text(1, y,  pText, localcolor, 0);
	gui_BLT_double_buffer(0,y,UI_device_width - 1,y+nFontHeight);
}


/*****************************************************************************
*  gbcp_file_read
*****************************************************************************/
int gbcp_file_read(char *ansii_filename, char* tmp_buf,  U32 nBufSize)
{
	FS_HANDLE FH = -1;
	U32  	nFileSize = 0;
	char	wFilePath[256] = {0};
	U32	    rb;
	
    kal_wsprintf((WCHAR*)wFilePath, "%c:\\%s", (S8)gbcp_t_card_drv(), ansii_filename);
	FH = FS_Open((const WCHAR*)wFilePath, FS_READ_ONLY);	
	
	if (FH >= 0)
	{		
		FS_GetFileSize(FH, &nFileSize);
		if(nFileSize > nBufSize)
		{
			FS_Close(FH);	
			return -1;
		}
		FS_Seek(FH, 0, FS_FILE_BEGIN);
		FS_Read(FH, tmp_buf, nFileSize, &rb);		
		FS_Close(FH);	
	}	
	//...
	return nFileSize;
}

/*****************************************************************************
*  gbcp_file_read_ext  
*****************************************************************************/
int gbcp_file_read_ext(char *ansii_filename, int offset, int len, char* buf)
{
	FS_HANDLE FH = -1;
	U32  	nFileSize = 0;
	char	wFilePath[256] = {0};
	U32	    rb=0;
	
    kal_wsprintf((WCHAR*)wFilePath, "%c:\\%s", (S8)gbcp_t_card_drv(), ansii_filename);
	FH = FS_Open((const WCHAR*)wFilePath, FS_READ_ONLY);	
	
	if (FH >= 0)
	{
        if(offset >= 0)
		    FS_Seek(FH, offset, FS_FILE_BEGIN);
		FS_Read(FH, buf, len, &rb);		
		FS_Close(FH);	
	}	
	//...
	return rb;
}


/*****************************************************************************
*  gbcp_file_write
*****************************************************************************/
int gbcp_file_write(char *ansii_filename, char *pDataBuf, U32 nSize, BOOL bAppend)
{
	FS_HANDLE   FH = -1;
	char		wFilePath[256] = {0};
	U32	    	wb;
    U32         alreadywb = 0;
    int         ret = -1;

	if(ansii_filename[1] == ':')
		kal_wsprintf((WCHAR*)wFilePath, "%s", ansii_filename);
	else
		kal_wsprintf((WCHAR*)wFilePath, "%c:\\%s", (S8)gbcp_t_card_drv(), ansii_filename);
	
	if(!bAppend)
        FH = FS_Open((WCHAR *)wFilePath, FS_CREATE_ALWAYS);
    else
	    FH = FS_Open((WCHAR *)wFilePath, FS_CREATE|FS_READ_WRITE);

    if(FH < 0)
    {
        return -1;
    }
    
	FS_Seek(FH, 0, FS_FILE_END);

    do{
		ret = FS_Write(FH, pDataBuf + alreadywb, nSize - alreadywb, &wb);
        alreadywb += wb;
    }while(ret == FS_NO_ERROR && alreadywb < nSize);

	FS_Close(FH);

    //if(nCreateMethod == 2)
        //FS_SetAttributes((const WCHAR *)wFilePathBuffer, FS_ATTR_HIDDEN);
    return alreadywb;
}

void gbcp_file_set_hidden(char *ansii_filename)
{
    char wFilePath[256] = {0};
    kal_wsprintf((WCHAR*)wFilePath, "%c:\\%s", (S8)gbcp_t_card_drv(), ansii_filename);
    FS_SetAttributes((const WCHAR *)wFilePath, FS_ATTR_HIDDEN);
}

/*****************************************************************************
*  gbcp_create_dir
*****************************************************************************/
void gbcp_create_dir(char* dir)
{
	FS_HANDLE FH = -1;
	char      buffer [64]={0};

	kal_wsprintf((PU16)buffer, "%c:\\%s", (S8)gbcp_t_card_drv(), dir);
	if((FH = FS_Open((PU16)buffer, FS_OPEN_DIR | FS_READ_ONLY)) < 0)
		FS_CreateDir((const WCHAR *)buffer);
	else
		FS_Close(FH);
}

/*****************************************************************************
*  gbcp_check_file_exist
*****************************************************************************/
BOOL gbcp_check_file_exist(char *wFilePath)
{	
	FS_HANDLE File_handle = -1;

	File_handle = FS_Open((const WCHAR *)wFilePath, FS_READ_ONLY);
	if (File_handle >= 0)
	{
		FS_Close(File_handle);
		return TRUE;
	}
	return FALSE;
}

/*****************************************************************
*                     临时定时器函数                      *
******************************************************************/
void gbcp_start_temp_timer(S32 count, void (*callback) (void))
{
    //TurnOnBacklight(1);
    gui_start_timer(count, callback);
}



void cy_get_middle_string(char *str , char *str_begin , char *str_end , 
					   char **p_middle_str , int *middle_str_len)
{
#if 0
	char *p_middle_begin,*p_middle_end,*p = NULL,*q = NULL;
	if(str)
	{
		//get middle string start position
		if(str_begin)
		{
			p = strstr(str,str_begin);
		}
		p_middle_begin = p?p + strlen(str_begin):str;

		//get middle string end position
		if(str_end)
		{
			q = strstr(p_middle_begin,str_end);
		}
		p_middle_end = q?q:str + strlen(str);

		//return the middle string start position and length
		if(!p && !q)
		{
			*p_middle_str = NULL;
			*middle_str_len = 0;
		}
		else
		{
			*p_middle_str = p_middle_begin;
			*middle_str_len = p_middle_end - p_middle_begin;
		}

	}
#else

//此函数重写了
	//1.若获取失败，retstr = null , retstrlen = 0;
	//2.如果str,str_begin 为空，则返回失败
	//3.如果str_end为空，则返回寻找到str_begin开始到字符串结尾之间的字符串
	//4.如果找不到str_begin,则返回失败
	char *p_middle_begin,*p_middle_end,*p = NULL,*q = NULL;

	*p_middle_str = NULL;
	*middle_str_len = 0;

	if(str&&str_begin)
	{
		p = strstr(str,str_begin);
		if(p)
		{
			p_middle_begin = p + strlen(str_begin);
			if(str_end)
			{
				p = strstr(p_middle_begin,str_end);
				if(p)	
				{
					*p_middle_str = p_middle_begin;
					*middle_str_len = p - p_middle_begin;
				}
				else
				{
					//str中有str_begin，但没有str_end，返回str中str_begin之后所有数据
					*p_middle_str = p_middle_begin;
					*middle_str_len = strlen(p_middle_begin);
				}
			}
			else
			{
				*p_middle_str = p_middle_begin;
				*middle_str_len = strlen(p_middle_begin);
			}
			
		}
	}

#endif

}
//mmi_wcsstr(WCHAR * string,const WCHAR * str_char_set)

void cy_get_middle_string_w(WCHAR *str , WCHAR *str_begin , WCHAR *str_end , 
					   WCHAR **p_middle_str , int *middle_str_len)
{


	WCHAR *p_middle_begin,*p_middle_end,*p = NULL,*q = NULL;

	*p_middle_str = NULL;
	*middle_str_len = 0;

	if(str&&str_begin)
	{
		p = mmi_wcsstr(str,str_begin);
		if(p)
		{
			p_middle_begin = p + kal_wstrlen(str_begin);
			if(str_end)
			{
				p = mmi_wcsstr(p_middle_begin,str_end);
				if(p)	
				{
					*p_middle_str = p_middle_begin;
					*middle_str_len = p - p_middle_begin;
				}
				else
				{
					//str中有str_begin，但没有str_end，返回str中str_begin之后所有数据
					*p_middle_str = p_middle_begin;
					*middle_str_len = kal_wstrlen(p_middle_begin);
				}
			}
			else
			{
				*p_middle_str = p_middle_begin;
				*middle_str_len = kal_wstrlen(p_middle_begin);
			}
			
		}
	}

}