#include "MMI_features.h"
#include "MMI_include.h"
#include "med_utility.h"
#include "fs_gprot.h"
#include "ej_api_base.h"

void *ej_osl_malloc(ej_u32 size)
{
	return OslMalloc(size);
}

void ej_osl_free(void *p)
{
	OslMfree(p);
}

void *ej_scrmem_malloc(ej_u32 size)
{
#ifdef __ARM9_MMU__
	return mmi_frm_scrmem_alloc_framebuffer(size);
#else
	return mmi_frm_scrmem_alloc(size);
#endif
}

void ej_scrmem_free(void *p)
{
	mmi_frm_scrmem_free(p);
}

void *ej_med_malloc(ej_u32 size)
{
#if defined(__COSMOS_MMI_PACKAGE__)
	return applib_asm_alloc_anonymous(size);
#else
	return (void*)med_alloc_ext_mem(size);
#endif
}

void ej_med_free(void **ptr)
{
#if defined(__COSMOS_MMI_PACKAGE__)
	applib_asm_free_anonymous(*ptr);
	*ptr = 0;
#else
	med_free_ext_mem(ptr);
#endif
}

void *ej_memcpy(void *d, const void *s, ej_s32 n)
{
	return (void*)memcpy(d,s,n);
}

void *ej_memmove(void *d, const void *s, ej_s32 n)
{
	return (void*)memmove(d,s,n);
}

void ej_memset(void *buf,ej_s32  value,ej_u32 size)
{
	memset(buf,value,size);
}


ej_s32 ej_strlen(const ej_s8* text)
{
	return (ej_s32 )strlen((const char*)text);
}

ej_s8* ej_strcpy(ej_s8* text1 ,const ej_s8* text2)
{
	return (ej_s8*)strcpy((char*) text1, (const char*)text2); 
}

ej_s8* ej_strncpy(ej_s8* text1 ,const ej_s8* text2,ej_s32 n)
{
	return (ej_s8*)strncpy((char*) text1, (const char*)text2,n); 
}

ej_s8* ej_strcat(ej_s8* text1 ,const  ej_s8* text2)
{
	return (ej_s8*)strcat((char*) text1, (const char*)text2); 
}

ej_s32 ej_strcmp(const ej_s8* text1 ,const  ej_s8* text2)
{
	return (ej_s32)strcmp((const char*)text1,(const char*)text2); 
}

ej_s32 ej_strncmp(const ej_s8* text1 ,const  ej_s8* text2,ej_s32 n)
{
	return (ej_s32)strncmp((const char*)text1, (const char*)text2,n); 
}

ej_s32 ej_atoi(const ej_s8* s)
{
	return (ej_s32)atoi((const char*) s);
}

ej_s8* ej_itoa_ext(ej_s32 value , ej_s8* buffer , ej_s32 radix)
{
	ej_u32  v = (ej_u32)value;
	ej_s8   *s;
	ej_u32  rem;
	ej_s8   rev[32 + 1];
	ej_s8   *p = buffer;

#define EJ_CONV_MAX_LEN (32)
	rev[EJ_CONV_MAX_LEN] = 0;
	if (value == 0)
	{
		buffer[0] = '0';
		buffer[1] = 0;
		return p;
	}

	s = &rev[EJ_CONV_MAX_LEN];
	while (v)
	{
	rem = v % radix;
		if (rem < 10) 
		{
			*--s = rem + '0';
		}
		else if (radix == 16)
		{
			*--s = "abcdef"[rem - 10];
		}
		v /= radix;
	}

	while (*s) 
	{
		buffer[0] = *s++;
		++ buffer;
	}
	*buffer = 0;
	return p;
}

ej_s8* ej_strstr(ej_s8 *p1, ej_s8 *p2)
{
	return (ej_s8*)strstr((char*)p1, (char*)p2);
}

ej_s8* ej_strchr(ej_s8 *s, ej_s8 c)
{
	return (ej_s8*)strchr(s, c);
}

ej_u16* ej_ucs2_strcat(ej_u16 *strDestination, const ej_u16 *strSource)
{
	return (ej_u16*) app_ucs2_strcat((kal_int8 *)strDestination,(const kal_int8 *)strSource);	
}

ej_u16* ej_ucs2_strcpy(ej_u16 *strDestination, const ej_u16 *strSource)
{
	return (ej_u16 *) app_ucs2_strcpy((kal_int8 *)strDestination, (const kal_int8 *)strSource);
}

ej_s32 ej_ucs2_strcmp(const ej_u16 *string1, const ej_u16 *string2)
{
	return (ej_s32) app_ucs2_strcmp(( const kal_int8 * )string1, ( const kal_int8 * )string2);
}

ej_s32 ej_ucs2_strncmp(const ej_u16* str1, const ej_u16* str2, ej_u32 size)
{
	return (ej_s32)app_ucs2_strncmp((const kal_int8*)str1, (const kal_int8*)str2, (kal_uint32)size);
}

ej_s32 ej_ucs2_strlen(const ej_u16 *arrOut)
{
	return (ej_s32)app_ucs2_strlen((const kal_int8 *)arrOut);
}

ej_u16* ej_ucs2_strstr(ej_u16 *string2, ej_u16 *string1)
{
	return (ej_u16*)app_ucs2_strstr((const kal_wchar *)string2, (const kal_wchar *)string1); 
}

ej_u16 ej_asc_to_ucs2(ej_u16 *pOutBuffer, ej_s8 *pInBuffer)
{
	return (ej_u16) app_asc_str_to_ucs2_str((kal_int8 *)pOutBuffer, (kal_int8 *)pInBuffer);
}

ej_s8* ej_ucs2_to_asc(ej_s8 *asic, ej_u16 *ucs2)
{
	ej_u16 count;
	count = (ej_u16)app_ucs2_str_to_asc_str((kal_int8 *)asic, (kal_int8 *)ucs2);
	asic[count] = 0;

	return asic;
}


// 系统盘符号
char ej_get_sys_symbol(void)
{
	return (char)FS_GetDrive(FS_DRIVE_I_SYSTEM, 1, FS_NO_ALT_DRIVE );//系统盘符号
}

// 存储卡盘符号
char ej_get_flash_symbol(void)
{
	return (char)FS_GetDrive(FS_DRIVE_V_REMOVABLE, 1, FS_NO_ALT_DRIVE);//存储卡盘符号
}

// 手机盘符号
char ej_get_phone_symbol(void)
{
	return (char)FS_GetDrive(FS_DRIVE_V_NORMAL, 1, FS_DRIVE_V_NORMAL | FS_DRIVE_V_REMOVABLE);//手机盘符号
}

void ej_get_time(MyTime *time)
{
    MYTIME currTime;

    GetDateTime(&currTime);
    time->nYear = currTime.nYear;
    time->nMonth = currTime.nMonth;
    time->nDay = currTime.nDay;
    time->nHour = currTime.nHour;
    time->nMin = currTime.nMin;
    time->nSec = currTime.nSec;
    time->DayIndex = currTime.DayIndex;
}

#include "fs_gprot.h"
ej_s32 ej_enhanced_FS_Open(ej_u16* FileName, ej_u32 Flag)
{
    FS_HANDLE       fp; 
    U16             *tmp;

    if (FileName[0] != ej_get_phone_symbol() && 
        FileName[0] != ej_get_flash_symbol()) {
        fp = 0;
    } else {
        fp = FS_Open((U16*)FileName, Flag);
        if(fp > FS_NO_ERROR) return fp;
    }

    tmp = (U16*)ej_osl_malloc(128);
    if(!tmp) return 0;
    
    ej_ucs2_strcpy(tmp, FileName);
    tmp[0] = ej_get_phone_symbol();
    fp = FS_Open(tmp, Flag);

    if(fp <= FS_NO_ERROR) {
        tmp[0] = ej_get_flash_symbol();
        fp = FS_Open(tmp, Flag);
    }
    ej_osl_free(tmp);
    return fp;
}

void  ej_simpletts_log(const char *pText,int iStatus)
{
	FS_HANDLE fp; 
	UINT Written = 0;
	S8 path[32];
	S8 filename[64];
	UINT nBufferBytes;
	
	sprintf(path,"%c:\\simpletts.txt",FS_GetDrive(FS_DRIVE_V_REMOVABLE, 1, FS_NO_ALT_DRIVE));
	mmi_asc_to_ucs2((S8*)filename, (S8*)path);
	fp = ej_enhanced_FS_Open((U16*)filename, FS_CREATE  | FS_READ_WRITE);
	if( fp > FS_NO_ERROR) {
		FS_Seek(fp, 0,FS_FILE_END);
		nBufferBytes = strlen((const char*)pText);
		FS_Write( fp,(void*)pText, nBufferBytes, &Written);
		strcpy(path,"\r\n");
		nBufferBytes = strlen((const char*)path);
		FS_Write( fp,(void*)path, nBufferBytes, &Written);
		FS_Close(fp);
	}
}

void ej_simpletts_printf(const char *fmt, ...)
{
#ifdef SKY_USE_TRACE
	va_list args;
	char *ej_simpetts_log_buffer = 0;

	ej_simpetts_log_buffer = (char*)ej_osl_malloc(1024);
        if(!ej_simpetts_log_buffer) return;
	va_start(args, fmt);
	vsprintf(ej_simpetts_log_buffer,fmt,args);
	va_end(args);
	ej_simpletts_log(ej_simpetts_log_buffer, 0);

	ej_osl_free((void*)ej_simpetts_log_buffer);
#endif
}

/*
* 可控制化的系统菜单模块
*/
#include "Wgui_fixed_menus.h"
#include "GlobalResDef.h"
typedef void(*ej_VOID_FUNC)(void);
typedef struct TagMyFuncAndString
{
	ej_VOID_FUNC        Func[32];
	ej_u16              *WString[32];
	ej_u16              *PopString[32];
	ej_u16              Icon[32];
	ej_s32              Total;
}TMyFuncAndString,*PMyFuncAndString;

static PMyFuncAndString gHMyFuncAndString = 0;

void MyFuncAndStringInit(void)
{
	if(0 == gHMyFuncAndString) 
	{
		gHMyFuncAndString = (PMyFuncAndString)ej_osl_malloc(sizeof(TMyFuncAndString));
		gHMyFuncAndString->Total = 0;
	}
}

void MyFuncAndStringDeinit(void)
{
	if(gHMyFuncAndString)
	{
		ej_osl_free(gHMyFuncAndString);
		gHMyFuncAndString = 0;
	}
}

void MyFuncAndStringAddItem(ej_VOID_FUNC Func, ej_u16 *WString, ej_u16 *WPopString)
{
	if(gHMyFuncAndString->Total < 32)
	{
		gHMyFuncAndString->Func[gHMyFuncAndString->Total] = Func;
		gHMyFuncAndString->WString[gHMyFuncAndString->Total] = WString;
		gHMyFuncAndString->Icon[gHMyFuncAndString->Total] = gHMyFuncAndString->Total + IMG_GLOBAL_L1;
		gHMyFuncAndString->PopString[gHMyFuncAndString->Total] = WPopString;
		++gHMyFuncAndString->Total;
	}
}

void MyFuncAndStringLskHdl(void)
{
	if(MMI_fixed_list_menu.highlighted_item >= gHMyFuncAndString->Total)
		return;
	if(gHMyFuncAndString->Func[MMI_fixed_list_menu.highlighted_item])
		(gHMyFuncAndString->Func[MMI_fixed_list_menu.highlighted_item])(); 
}

ej_u16 **MyFuncAndStringGetStrList(void)
{
	return gHMyFuncAndString->WString;
}

ej_u16 **MyFuncAndStringGetPopStrList(void)
{
	return gHMyFuncAndString->PopString;
}

ej_s32 MyFuncAndStringGetTotal(void)
{
	return gHMyFuncAndString->Total;
}

ej_u16*MyFuncAndStringGetIconList(void)
{
	return gHMyFuncAndString->Icon;
}

extern ej_s32 UI_device_width;
extern ej_s32 UI_device_height;
ej_s32 ej_get_device_width(void)
{
	return (ej_s32)UI_device_width;
}

ej_s32 ej_get_device_height(void)
{
	return (ej_s32)UI_device_height;
}

ej_bool  ej_phone_sim_is_available(void)
{
        return ((srv_sim_ctrl_is_available(MMI_SIM1) && !srv_nw_info_sim_is_rejected(MMI_SIM1))
                || (srv_sim_ctrl_is_available(MMI_SIM2) && !srv_nw_info_sim_is_rejected(MMI_SIM2))
        ) ? ej_true : ej_false;
}