#ifdef __MMT_TWEETY_BIRD_SLIM_GAME_SUPPORT__


#include "TweetyBird_common.h"
#include "SmsSrvGprot.h"
#include "mmi_rp_app_tweetybird_def.h"
#include "common_nvram_editor_data_item.h"
#include "ImeiSrvGprot.h"
#include "SmsSrvGprot.h" 
#include "mmi_frm_mem_gprot.h"
#include "gui.h"
#include "gdi_include.h"
#include "mdi_audio.h"
#include "GlobalResDef.h"
#include "wgui_categories_util.h"
#include "mmi_rp_app_games_def.h"
extern BOOLEAN TweetyBird_new_game;
/* -------------------------COMMON BILLING-------------------------------------------
OEM check
-------------------------------------------------------------------------*/

#if defined MMT_GAME_SYMPHONY
#define TWEETY_BIRD_TRIAL_BASE_BILLING					TRUE
#define TWEETY_BIRD_GAME_INPUT_LEVEL						"4"

#elif defined MMT_GAME_MICROMAX
#define TWEETY_BIRD_TRIAL_BASE_BILLING					TRUE
#define TWEETY_BIRD_GAME_INPUT_LEVEL						"9"

#else
#define TWEETY_BIRD_TRIAL_BASE_BILLING					TRUE
#define TWEETY_BIRD_GAME_INPUT_LEVEL						"5"

#endif


// resume on any interrupt on trial
#if defined MMT_GAME_KARBONN_UTL
	#define TWEETY_BIRD_ENABLE_RESUME_ON_TRIAL		TRUE
#else
	#define TWEETY_BIRD_ENABLE_RESUME_ON_TRIAL		FALSE
#endif


/*********************************** USE FOR BILLING TESTING ONLY **********************************/
//#define TWEETY_BIRD_BILLING_TEST            // define the macro only for testing
#define TWEETY_BIRD_BILLING_NO			"0000000000"
/*************************************************************************************************/

// timer speed - reduce timer value to increase game speed
#define TWEETY_BIRD_TIMER 5


/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
*
* PARAMETERS
* None
* RETURNS
* None
****************************************************************************/
U16 TweetyBird_get_image_id(int ResId) {
//#if __SPD__
	return  (APP_TWEETYBIRD+ResId+1);    
//#endif
}


/*****************************************************************************
* FUNCTION
*
*
* PARAMETERS
* None
* RETURNS
* None
****************************************************************************/
U8* TweetyBird_get_image(S16 img_id)
{
   	U8* image = NULL;
    image = (U8 *)get_image(TweetyBird_get_image_id(img_id));
    return (image);
}



 
/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
*
* PARAMETERS
* None
* RETURNS
* None
****************************************************************************/
int TweetyBird_graphic_get_screen_width(void)
{
	S32 screen_width=0;
	S32  screen_height=0;
	gdi_lcd_get_dimension(&screen_width, &screen_height);
	return screen_width;
}

/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
*
* PARAMETERS
* None
* RETURNS
* None
****************************************************************************/
int TweetyBird_graphic_get_screen_height(void)
{
	S32 screen_width=0;
	S32  screen_height=0;
	gdi_lcd_get_dimension(&screen_width, &screen_height);
	return screen_height;
}

/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
*
* PARAMETERS
* None
* RETURNS
* None
****************************************************************************/
void TweetyBird_exit_app(void)
{
	TweetyBird_StopSound();	
	TweetyBird_new_game = TRUE;
#if __SPD__
	MMK_CloseWin(TweetyBird_win_id);
    return;
 #else
 	GoBackHistory();
#endif
    return;
}

/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
*
* PARAMETERS
* None
* RETURNS
* None
****************************************************************************/
void TweetyBird_Draw_Rect(int  x, int  y ,int  width, int  height ,GUI_COLOR_T line_color, GUI_COLOR_T back_color,U8 choice)
{
#if __SPD__
    GUI_LCD_DEV_INFO    lcd_dev_info = {GUI_MAIN_LCD_ID, GUI_BLOCK_MAIN};
    GUI_RECT_T      rect ;
    rect.left = x;
    rect.right = x+width;
    rect.top = y;
    rect.bottom = y+height;
#endif    
    switch(choice)
    {
     	case DRAW_FILL_RECT:
#if __SPD__
			GUI_FillRect(&lcd_dev_info, rect, back_color);
			LCD_DrawRect(&lcd_dev_info, rect, line_color);
#else
			gui_fill_rectangle(x, y, x+width, y+height, back_color);
			gui_draw_rectangle(x, y, x+width, y+height, line_color);
#endif    

  		break;
   		case DRAW_RECT:
#if __SPD__
		  LCD_DrawRect(&lcd_dev_info, rect, line_color);
 #else
			gui_draw_rectangle(x, y, x+width, y+height, line_color);
#endif    
   	break;
    	case DRAW_ROUND_RECT:
#if __SPD__
		    LCD_DrawRoundedRect(&lcd_dev_info, rect, rect,line_color);
 #else
 		gdi_draw_round_rect(x, y, x+width, y+height, gdi_act_color_from_rgb(255,247,166,14),gdi_act_color_from_rgb(255,255,255,255),2);
 		//gui_draw_gradient_rounded_rectangle(x, y, x+width, y+height, line_color,back_color,1);
#endif    
   	break;
    }

}

/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
*
* PARAMETERS
* None
* RETURNS
* None
****************************************************************************/
static BOOL  IsGameAudioOn(void)
{
	BOOL isAudioOn = TRUE;
	S16 error;
    ReadValue(NVRAM_GFX_AUDIO_SETTING, &isAudioOn, DS_BYTE, &error);

    /* if not init, init as ON */
    if (isAudioOn == 0xff)
    {
        isAudioOn = TRUE;
        WriteValue(NVRAM_GFX_AUDIO_SETTING, &isAudioOn, DS_BYTE, &error);
    }
	return isAudioOn;
}


static U8 GetGameAudioVolumn(void)
{
	U8 audioVolumn = LEVEL4;
	S16 error;
    ReadValue(NVRAM_GFX_AUDIO_VOLUMN, &audioVolumn, DS_BYTE, &error);
    if (audioVolumn == 0xff)
    {
        audioVolumn = LEVEL4;
        WriteValue(NVRAM_GFX_AUDIO_VOLUMN, &audioVolumn, DS_BYTE, &error);
    }
	return audioVolumn;
}

/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
*
* PARAMETERS
* None
* RETURNS
* None
****************************************************************************/
void TweetyBird_play_ring(U16 ring_id)
{
	U8 audio_type;
	U32 audio_len;
	U8 *audio_data;
	S32 result;
	if(IsGameAudioOn())
	{
		//AUD_TWEETYBIRD_LVL_COMP_RING
		audio_data = get_audio(AUD_TWEETYBIRD_BG_RING+ring_id-1, &audio_type, &audio_len);
		if(audio_data != NULL)
		{
			result = mdi_audio_play_string_with_vol_path(
					(void*)audio_data,
					audio_len,
					audio_type,
					((ring_id==1)?DEVICE_AUDIO_PLAY_INFINITE:DEVICE_AUDIO_PLAY_ONCE),
					NULL,
					NULL,
					GetGameAudioVolumn(),
					MDI_DEVICE_SPEAKER_BOTH);
		}
	}
}

/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
*
* PARAMETERS
* None
* RETURNS
* None
****************************************************************************/
void TweetyBird_stop_sound()
{
#if __SPD__
	MMIAPISET_StopRing(MMISET_RING_TYPE_TWEETYBIRD);
#endif    
	mdi_audio_stop_string();

}

/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
*
* PARAMETERS
* None
* RETURNS
* None
****************************************************************************/
void TweetyBird_game_read_nvram(void *game_data)
{
#if __SPD__
    MN_RETURN_RESULT_E      return_value = MN_RETURN_FAILURE;
    MMINV_READ(MMINV_GMTWEETYBIRD_GAME_DATA, game_data, return_value);
 #else
   S32    error      = NVRAM_WRITE_FAIL;
	ReadRecord(NVRAM_EF_GAME_TWEETYBIRD_DATA_LID, 1, (void*)game_data, NVRAM_EF_GAME_TWEETYBIRD_DATA_SIZE, (S16 *)&error);
#endif    
}

/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
*
* PARAMETERS
* None
* RETURNS
* None
****************************************************************************/
void TweetyBird_game_write_nvram(void *game_data)
{
#if __SPD__
    MN_RETURN_RESULT_E      return_value = MN_RETURN_FAILURE;
    MMINV_WRITE(MMINV_GMTWEETYBIRD_GAME_DATA,game_data);
#else
    S32    error      = NVRAM_WRITE_FAIL;
	WriteRecord(NVRAM_EF_GAME_TWEETYBIRD_DATA_LID, 1, (void*)game_data, NVRAM_EF_GAME_TWEETYBIRD_DATA_SIZE, (S16 *)&error);
#endif    
}

/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
*
* PARAMETERS
* None
* RETURNS
* None
****************************************************************************/
void TweetyBird_DrawImageAtPos(VMINT nX, VMINT nY,VMINT ResID,VMINT nSourceOffsetX, VMINT nSourceOffsetY,VMINT nWidth, VMINT nHeight, VMINT nFrameNumber,VMINT Alpha)
{
#if __SPD__
    GUI_LCD_DEV_INFO    lcd_dev_info = {GUI_MAIN_LCD_ID, GUI_BLOCK_MAIN};
    GUI_RECT_T     display_rect, img_rect ;
	display_rect.left = nX;  
	display_rect.top = nY;
	display_rect.right = nX+nWidth -1;
	display_rect.bottom = nY+nHeight -1;
	
	img_rect.left = nSourceOffsetX;  
	img_rect.top = nSourceOffsetY;
	img_rect.right = nSourceOffsetX+nWidth-1;
	img_rect.bottom = nSourceOffsetY+nHeight-1;
	if(Alpha == FONT_WHITE)
	{
		GUIRES_DisplayImgWitchColorExchange(
	                        PNULL,
	                        &display_rect,
	                        &img_rect,
	                        TweetyBird_win_id,
	                        TweetyBird_get_image_id(ResID),
	                        &lcd_dev_info,
	                        TRUE,
	                        GUI_RGB2RGB565(255,255,255)
	                        );
	}
	else
	{
	        GUIRES_DisplayImg(
                        PNULL,
                        &display_rect,
                        &img_rect,
                        TweetyBird_win_id,
                        TweetyBird_get_image_id(ResID),
                        &lcd_dev_info);
		}
#else	
	S32 x1, y1, x2, y2;
	S32 img_width,img_height;  
	U8 *img_data;
    img_data= TweetyBird_get_image(ResID);
	//if(Alpha == FONT_WHITE)
	//{
	//	TweetyBird_changeColor(img_data,255,255,255);
	//}
	gui_measure_image(img_data , &img_width , &img_height);
	gui_get_clip(&x1, &y1, &x2, &y2);
	gui_set_clip(nX, nY, nX+nWidth-1, nY+nHeight-1);
	gdi_image_codec_draw(GDI_IMAGE_SRC_FROM_RESOURCE,
		img_data,
		GDI_IMAGE_TYPE_INVALID,
		0,
		nX - nSourceOffsetX,
		nY - nSourceOffsetY,
        img_width,
        img_height ,
		0,
		0);
	gui_set_clip(x1, y1, x2, y2);	
#endif    
}

/**/
//Vertical Flip  
//	A		|
//	|  to	V

/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
*
* PARAMETERS
* None
* RETURNS
* None
****************************************************************************/
void TweetyBird_DrawVerticalFlipImage(VMINT nDestX, VMUINT nDestY,VMINT ResID,VMINT nSourceOffsetX, VMINT nSourceOffsetY,VMINT nWidth, VMINT nHeight,VMINT a_nCurFrame,VMINT Alpha)
{
	int  i= 0;
	for(i= 0; i< nHeight; i++)
	{
		TweetyBird_DrawImageAtPos(nDestX , nDestY + nHeight - 1 - i,ResID,0,i,nWidth,1,a_nCurFrame,Alpha);
	}
}

//Rotate 90 Degrees Clockwise
//	^		-->
//	|	to	
/**/
/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
*
* PARAMETERS
* None
* RETURNS
* None
****************************************************************************/
void TweetyBird_Draw90DegreesClockwiseRotatedImage(VMUINT nDestX, VMINT nDestY,VMINT ResID,VMINT nSourceOffsetX, VMINT nSourceOffsetY,VMINT nWidth, VMINT nHeight,VMINT a_nCurFrame,VMINT Alpha)
{
	int i=0,j=0;

	for( j = 0; j< (nWidth); j++)
	{
		for( i = 1; i< (nHeight); i++)
		{
			TweetyBird_DrawImageAtPos(nDestX+i, nDestY+j,ResID,j, nHeight-i-1, 1, 1 ,1,Alpha);
		}
	}
}

/**/
//Rotate 90 Degrees AntiClockwise
//	^		<--
//	|	to
/**/	
/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
*
* PARAMETERS
* None
* RETURNS
* None
****************************************************************************/
void TweetyBird_Draw90DegreesAntiClockwiseRotatedImage(VMUINT nDestX, VMUINT nDestY,VMINT ResID,VMINT nSourceOffsetX, VMINT nSourceOffsetY,VMINT nWidth, VMINT nHeight,VMINT a_nCurFrame,VMINT Alpha)
{
	
	int i=0,j=0;
	for( j = 0; j< (nWidth); j++)
	{
		for( i = 1; i< (nHeight); i++)
		{
			TweetyBird_DrawImageAtPos(nDestX+i, nDestY+j,ResID, nWidth-j-1, i,1, 1 ,1,Alpha);
		}
	}

}

/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
*
* PARAMETERS
* None
* RETURNS
* None
****************************************************************************/
#if __SPD__
void TweetyBird_Send_Sms(uint8* number, U8* msg,MN_DUAL_SYS_E  sim_id, void* callback)
#else
void TweetyBird_Send_Sms(U8* number, U8* msg,U8  sim_id, void* callback)
#endif
{
#if __SPD__
	int8  content_len;
	int8* content_ucs2_buffer = NULL;
    MMISMS_SEND_DATA_T send_data = {0};
    MMI_STRING_T    message_content = {0};
	
	content_len = strlen((int8*) msg );
	
	content_ucs2_buffer = SCI_ALLOCAZ((content_len+1) * 2);
	memset(content_ucs2_buffer,0,((content_len+1) * 2));
	MMIAPICOM_StrToWstr(msg,content_ucs2_buffer);
    message_content.wstr_ptr = content_ucs2_buffer;
    message_content.wstr_len = MMIAPICOM_Wstrlen(message_content.wstr_ptr);
    send_data.sms_content_ptr = &message_content;
    send_data.dst_port = 0;
    send_data.src_port = 0;
    send_data.dest_addr_ptr = (uint8 *)number;
    send_data.dest_addr_len = strlen(number);
    send_data.dual_sys = sim_id;
    send_data.is_need_packet = TRUE;
    send_data.send_callback = (SMS_SEND_CALLBACK)callback;
	
    MMIAPISMS_SendSmsForOther(&send_data);
	SCI_FREE(content_ucs2_buffer);
	
#else
	U8 content_len;
	PS8 content_ucs2_buffer = NULL;
	S8 ucs2_addr[(SRV_SMS_MAX_ADDR_LEN+1)*ENCODING_LENGTH];

	SMS_HANDLE g_sms_handler = srv_sms_get_send_handle();
	
	if(srv_sim_ctrl_is_available((mmi_sim_enum)MMI_SIM1) == MMI_TRUE)
	{
		srv_sms_set_sim_id(g_sms_handler, (srv_sms_sim_enum) SRV_SMS_SIM_1);
	}
	else if (srv_sim_ctrl_is_available((mmi_sim_enum)MMI_SIM2) == MMI_TRUE)
	{
		srv_sms_set_sim_id(g_sms_handler, (srv_sms_sim_enum) SRV_SMS_SIM_2);
	}
	else
	{
#ifdef MMT_GAME_UNLOCK_TRACE
		kal_prompt_trace(MOD_MMI, "[MMT_Game] srv_sim_ctrl_is_available(MMI_SIM2 failed!)");
#endif
		return; 	
	}
	memset(ucs2_addr, 0, ((SRV_SMS_MAX_ADDR_LEN+1)*ENCODING_LENGTH));
	content_len = strlen((S8*) msg );
	content_ucs2_buffer = OslMalloc((content_len+1) * ENCODING_LENGTH);
	memset(content_ucs2_buffer,0,((content_len+1) * ENCODING_LENGTH));
	mmi_asc_to_ucs2((S8*)ucs2_addr,(S8*)number);
	mmi_asc_n_to_ucs2((S8*)content_ucs2_buffer,(S8*)msg,(U32)((content_len+1)*ENCODING_LENGTH));	
	srv_sms_set_content(g_sms_handler, content_ucs2_buffer,(U16) ((content_len+1)*ENCODING_LENGTH));
#if defined(__UNIFIED_MESSAGE_BACKGROUND_SEND_SUPPORT__)
	srv_sms_set_send_type(g_sms_handler, (srv_sms_send_type_enum)SRV_SMS_BG_SEND); 
#else
	srv_sms_set_send_type(g_sms_handler, (srv_sms_send_type_enum)SRV_SMS_FG_SEND);
#endif
	srv_sms_set_content_dcs(g_sms_handler, (srv_sms_dcs_enum) SRV_SMS_DCS_7BIT);
	srv_sms_set_address(g_sms_handler, (S8*)ucs2_addr);
	srv_sms_set_status_report(g_sms_handler, MMI_FALSE);
	OslMfree(content_ucs2_buffer);
	srv_sms_send_msg(g_sms_handler, callback, NULL);
	//return TRUE;
#endif
	
}

MMI_ID TweetyBird_grp_id;

/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
* PARAMETERS
*  evt     [?]     
* RETURNS
*  MMI_RET_OK
*****************************************************************************/
mmi_ret TweetyBird_group_proc(mmi_event_struct *evt)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/

    switch (evt->evt_id)
    {
    default:
        {

        }
        break;
    }
    return MMI_RET_OK;
}

void TweetyBird_enter_game_func()
{
    if(!(mmi_frm_scrn_enter(TweetyBird_grp_id,SCR_ID_TWEETYBIRD_GAME,
        TweetyBird_Resume_Game,
        TweetyBird_enter_game_func, MMI_FRM_FULL_SCRN)))
    {
        //mmt_game_unlock_error_scr_entry_error_hdlr(SCR_ID_GAME_NATIVE_UNLOCK_ENTER_UNLOCK_SCREEN);
        return;
    }
	TweetyBird_Enter_Game();
}

/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
*  
* PARAMETERS
*  U16 
* RETURNS
*  U16
*****************************************************************************/
void TweetyBird_create_grp()
{
     U8  state;
     S16 error;
 	TweetyBird_grp_id = mmi_frm_group_create(GRP_ID_ROOT,GRP_ID_TWEETYBIRD_GAME,
        TweetyBird_group_proc,NULL);

    mmi_frm_group_enter(TweetyBird_grp_id,MMI_FRM_NODE_SMART_CLOSE_FLAG);
    TweetyBird_enter_game_func();

    //mmi_frm_scrn_first_enter(ball_crush_grp_id,SCR_ID_BALL_CRUSH_GAME,ball_crush_Enter_GFX,NULL);
		
}


MMI_BOOL TweetyBird_game_active()
{
	if(mmi_frm_scrn_is_present(TweetyBird_grp_id,SCR_ID_TWEETYBIRD_GAME,MMI_FRM_NODE_ALL_FLAG))
   	return TRUE;
   else
   	return FALSE;
}

 U16 TweetyBird_get_global_id()
 {
 	return MMI_EVENT_SUCCESS;
 }

color TweetyBird_color (U8 r, U8 g, U8 b) {
	return(gui_color(r, g, b));
}


/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
*
* PARAMETERS
* None
* RETURNS
* None
****************************************************************************/
int TweetyBird_get_timer_value(void)
{	
   return TWEETY_BIRD_TIMER;
}

/*****************************************************************************
* FUNCTION
*  
* DESCRIPTION
*  
*
* PARAMETERS
* None
* RETURNS
* None
****************************************************************************/
MMI_BOOL TweetyBird_interrupt_handle_support()
{
	return TWEETY_BIRD_ENABLE_RESUME_ON_TRIAL;
}

U8 TweetyBird_IsOEM_MAXX(void)
{
#ifdef MMT_GAME_MAXX
	return TRUE;
#else
	return FALSE;
#endif
}

U8 TweetyBird_IsOEM_Micromax(void)
{
#ifdef MMT_GAME_MICROMAX
	return TRUE;
#else
	return FALSE;
#endif
}

U8 TweetyBird_IsOEM_IBall(void)
{
#ifdef MMT_GAME_IBALL
	return TRUE;
#else
	return FALSE;
#endif
}

U8 TweetyBird_IsOEM_KarbonnJDelhi(void)
{
#ifdef MMT_GAME_KARBONN_J_DELHI
	return TRUE;
#else
	return FALSE;
#endif
}

U8 TweetyBird_IsOEM_KarbonnUTL(void)
{
#ifdef MMT_GAME_KARBONN_UTL
	return TRUE;
#else
	return FALSE;
#endif
}

U8 TweetyBird_IsOEM_Lava(void)
{
#ifdef MMT_GAME_LAVA
	return TRUE;
#else
	return FALSE;
#endif
}

U8 TweetyBird_IsBangladeshBilling(void)
{
#ifdef MMT_GAME_SYMPHONY
	return TRUE;
#else
	return FALSE;
#endif
}

U8 TweetyBird_IsTrialBaseBilling(void)
{
	return (TWEETY_BIRD_TRIAL_BASE_BILLING);
}

U8* TweetyBird_GetGameInputLevel(void)
{
	return (TWEETY_BIRD_GAME_INPUT_LEVEL);
}

int TweetyBird_GetMaxTrials(void)
{
	if (TweetyBird_IsOEM_Micromax() == TRUE)
	{
		return 1;
	}
	return 3;
}


/****************** TESTING FUNCTION *********************/
U8* TweetyBirdBillingTest(void)
{
#ifdef TWEETY_BIRD_BILLING_TEST
	return (TWEETY_BIRD_BILLING_NO);
#else
	return 0;
#endif
}

#endif