// libc
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <kwrap/type.h>
#include <kwrap/platform.h>
#include <kwrap/flag.h>
#include "UIWnd/UIFlow.h"
#include "System/SysMain.h"
#include "hdal.h"
#include "SxTimer/SxTimer.h"
#include "DrvExt.h"
#include "comm/hwclock.h"
#include "comm/timer.h"
#include <io/gpio.h>
#include <IOCfg.h>
#include "mem_hotplug.h"
#if HUNTING_CAMERA_MCU == ENABLE
#include <sf_inc.h>
#include "sf_log.h"
#endif

#include "SF_SysStrgMng.h"


///////////////////////////////////////////////////////////////////////////////
#define __MODULE__          main
#define __DBGLVL__          2 // 0=FATAL, 1=ERR, 2=WRN, 3=UNIT, 4=FUNC, 5=IND, 6=MSG, 7=VALUE, 8=USER
#define __DBGFLT__          "*" //*=All, [mark]=CustomClass
#include <kwrap/debug.h>
///////////////////////////////////////////////////////////////////////////////

#define DEFAULT_YEAR 	2000
#define DEFAULT_MON 	1
#define DEFAULT_DAY 	1
#define DEFAULT_HOUR 	0
#define DEFAULT_MIN 	0
#define DEFAULT_SEC 	0

#define VENDOR_AI_CFG  				0x000f0000

extern void *vdoout_get_buf(void);
extern BOOL DrvCARD_DetStrgCard(void);

#if defined(_UI_STYLE_LVGL_)

/******************************************************
*  include headers
*******************************************************/
#include "lvgl/lvgl.h"
#include "lv_drivers/display/fbdev.h"

/******************************************************
*  extern function declaration
*******************************************************/
extern bool keypad_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data);
extern bool pointer_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data);
extern void lvglTimer(void);

extern void sf_log_sava(void);
/******************************************************
*  static variables
*******************************************************/
static lv_disp_buf_t disp_buf_2;


/******************************************************
*  global variables
*******************************************************/
lv_indev_t* indev_keypad = NULL;
lv_indev_t* indev_pointer = NULL;


int nvt_lvgl_init(void)
{
	/*-------------------------
	* Initialize your display
	* -----------------------*/

	/*LittlevGL init*/
	lv_init();

	/*Linux frame buffer device init*/
	fbdev_init();

	/*-----------------------------
	* Create a buffer for drawing
	*----------------------------*/
	/*Set a display buffer*/

#if LV_USE_GPU_NVT_DMA2D



	#if LV_USER_CFG_USE_TWO_BUFFER
		void *buf2_1 = (void *)((UINT32)fbp+(screensize*2));
	#else
		void *buf2_1 = (void *)((UINT32)fbp+screensize);
	#endif

#else
	lv_color_t* buf2_1 = (lv_color_t*) malloc(LV_HOR_RES_MAX * LV_VER_RES_MAX * sizeof(lv_color_t));  /*A screen sized buffer*/
	LV_ASSERT_NULL(buf2_1);
	memset(buf2_1, 0, LV_HOR_RES_MAX * LV_VER_RES_MAX * sizeof(lv_color_t));

	#if LV_USER_CFG_USE_TWO_BUFFER
		lv_color_t* buf2_2 = (lv_color_t*) malloc(LV_HOR_RES_MAX * LV_VER_RES_MAX * sizeof(lv_color_t));  /*A screen sized buffer*/
		LV_ASSERT_NULL(buf2_2);
		memset(buf2_2, 0, LV_HOR_RES_MAX * LV_VER_RES_MAX * sizeof(lv_color_t));
	#endif
#endif

	lv_disp_buf_init(&disp_buf_2, buf2_1, 0, LV_HOR_RES_MAX * LV_VER_RES_MAX);   /*Initialize the display buffer*/

	/*-----------------------------------
	* Register the display in LVGL
	*----------------------------------*/
	/*Add a display the LittlevGL sing the frame buffer driver*/
	lv_disp_drv_t disp_drv;
	lv_disp_drv_init(&disp_drv);

	//disp_drv.hor_res = LV_VER_RES_MAX;
	//disp_drv.ver_res = LV_HOR_RES_MAX;
	disp_drv.rotated = 0;

	/*Set a display buffer*/
	disp_drv.buffer = &disp_buf_2;

	/*Used to copy the buffer's content to the display*/
	disp_drv.flush_cb = disp_flush;

	disp_drv.rounder_cb = lv_user_rounder_callback;

#if LV_COLOR_DEPTH == 24
	disp_drv.set_px_cb = set_px_cb_8565;
#else
	disp_drv.set_px_cb = NULL;
#endif

	/*Finally register the driver*/
	lv_disp_t * disp;
	disp = lv_disp_drv_register(&disp_drv); /*It flushes the internal graphical buffer to the frame buffer*/

	lv_disp_drv_update(disp, &disp_drv);


    /*Register a keypad input device*/
    lv_indev_drv_t indev_drv;
    lv_indev_drv_init(&indev_drv);
    indev_drv.type = LV_INDEV_TYPE_KEYPAD;
    indev_drv.read_cb = keypad_read;
    indev_keypad = lv_indev_drv_register(&indev_drv);



    /*Register a keypad input device*/
    lv_indev_drv_init(&indev_drv);
    indev_drv.type = LV_INDEV_TYPE_POINTER;
    indev_drv.read_cb = pointer_read;
    indev_pointer = lv_indev_drv_register(&indev_drv);

    return 0;
}
#endif

int nvt_user_init(void)
{
    UXUSER_OBJ uxuser_param={0};
    ER ret=0;

    //project init
    UIControl_InstallID();

    uxuser_param.pfMainProc = UserMainProc;
	uxuser_param.pfNvtUserCB = UserErrCb;
    ret = Ux_Open(&uxuser_param);
    if(ret!=0){
		DBG_ERR("Ux_Open fail%d\r\n",ret);
		return -1;
    }

	BKG_OBJ uiBackObj = {0};
	//Init UI background
	uiBackObj.pDefaultFuncTbl = 0; //gBackgroundExtFuncTable
	uiBackObj.done_event = NVTEVT_BACKGROUND_DONE;
	ret = BKG_Open(&uiBackObj);
    if(ret!=0){
		DBG_ERR("BKG_Open fail%d\r\n",ret);
		return -1;
    }


    /* move lvgl timer here due to post event must after timer initialized */
#if defined(_UI_STYLE_LVGL_)

    TIMER_ID id;
	if (timer_open((TIMER_ID *)&id, (DRV_CB)lvglTimer) != E_OK) {
		DBG_ERR("timer trig open failed!\r\n");
		return -1;
	}

	timer_cfg(id, LV_DISP_DEF_REFR_PERIOD * 1000, TIMER_MODE_FREE_RUN | TIMER_MODE_ENABLE_INT, TIMER_STATE_PLAY);

#endif

    return 0;
}

int nvt_user_uninit(void)
{
	Ux_Close();
	BKG_Close();
    GxGfx_Exit();
    UIControl_UninstallID();
    return 0;
}

UINT32 nvt_hdal_init(void)
{
    HD_RESULT ret;
	HD_COMMON_MEM_INIT_CONFIG mem_cfg = {0};

	ret = hd_common_init(0);
    if(ret != HD_OK) {
        DBG_ERR("common init fail=%d\n", ret);
        return -1;
    }

#if MOVIE_AI_DEMO
	hd_common_sysconfig(HD_VIDEOPROC_CFG, (1<<16), HD_VIDEOPROC_CFG_GDC_BEST , VENDOR_AI_CFG);
#else
	hd_common_sysconfig(HD_VIDEOPROC_CFG, 0, HD_VIDEOPROC_CFG_GDC_BEST , 0);
#endif

#if defined(_UI_STYLE_LVGL_)
	#if LV_USER_CFG_USE_ROTATE_BUFFER
	mem_cfg.pool_info[0].type     = HD_COMMON_MEM_COMMON_POOL;
	mem_cfg.pool_info[0].blk_size = LOGO_BS_BLK_SIZE;
	mem_cfg.pool_info[0].blk_cnt  = 1;
	mem_cfg.pool_info[0].ddr_id   = DDR_ID0;
	#endif
#else
	#if (VDO_USE_ROTATE_BUFFER==ENABLE)
	mem_cfg.pool_info[0].type     = HD_COMMON_MEM_COMMON_POOL;
	mem_cfg.pool_info[0].blk_size = LOGO_BS_BLK_SIZE;
	mem_cfg.pool_info[0].blk_cnt  = 1;
	mem_cfg.pool_info[0].ddr_id   = DDR_ID0;
	#endif
#endif

	ret = hd_common_mem_init(&mem_cfg);
    if(ret != HD_OK) {
        DBG_ERR("mem init fail=%d\n", ret);
        return -1;
    }

    memory_hotplug();

    ret = hd_gfx_init();
    if(ret != HD_OK) {
        DBG_ERR("gfx init fail=%d\n", ret);
        return -1;
    }

    return 0;
}

UINT32 nvt_hdal_uninit(void)
{
    HD_RESULT ret;

    ret = hd_gfx_uninit();
    if(ret != HD_OK) {
        DBG_ERR("gfx uninit fail=%d\n", ret);
        return -1;
    }
	ret = hd_common_mem_uninit();
    if(ret != HD_OK) {
        DBG_ERR("mem uninit fail=%d\n", ret);
        return -1;
    }
	ret = hd_common_uninit();
    if(ret != HD_OK) {
        DBG_ERR("common uninit fail=%d\n", ret);
        return -1;
    }
    return 0;

}

ID FLG_ID_MAIN = 0;

#define FLG_MAIN_ON                  0x00000001      //
#define FLG_MAIN_OFF                 0x00000002      //
#define FLG_MAIN_COMMAND             (FLG_MAIN_ON|FLG_MAIN_OFF)      //

extern ID _SECTION(".kercfg_data") FLG_ID_MAIN;

void System_InstallID(void)
{
	OS_CONFIG_FLAG(FLG_ID_MAIN);
}

void System_PowerOnFinish(void)
{
	//clr_flg(FLG_ID_MAIN, FLG_MAIN_COMMAND);
	//sta_tsk(IDLETSK_ID,0);
	vos_flag_set(FLG_ID_MAIN, FLG_MAIN_ON);
}

void System_PowerOffStart(void)
{
	vos_flag_set(FLG_ID_MAIN, FLG_MAIN_OFF);
}

void System_WaitForPowerOnFinish(void)
{
	FLGPTN uiFlag;
	vos_flag_wait(&uiFlag, FLG_ID_MAIN, FLG_MAIN_ON, TWF_ORW);
}

void System_WaitForPowerOffStart(void)
{
	FLGPTN uiFlag;
	vos_flag_wait(&uiFlag, FLG_ID_MAIN, FLG_MAIN_OFF, TWF_ORW);
}
#if HUNTING_CAMERA_MCU == ENABLE
UINT8 sf_cardv_check_power_on_mode(void)
{
    FILE *fp = NULL;
    UINT32 u32ize = 0;
    char *pStrSrc = NULL;
    char *pStrOtsOk = "Mode=";
    char *pStrUpFw = "UpFw=";
    char *pStrUpMcu = "mcu=";
    char *pStrSF = "sf=";

    char *temp = NULL;
	UINT8 startup = 0;
	UINT8 UpFw = 0;
	UINT8 Upmcu = 0;
	UINT8 sftmp = 0;

    system("cat /proc/cmdline > /tmp/Mode.txt");
    fp = fopen("/tmp/Mode.txt","r");
    if(fp == NULL){
    	return FALSE;
    }

	fseek(fp, 0, SEEK_END);
	u32ize = ftell(fp); // take file size
	fseek(fp, 0, SEEK_SET); // move to position zero
	pStrSrc = (char *)malloc(u32ize*sizeof(char));
	if (pStrSrc) {
		fread(pStrSrc, 1, u32ize, fp);
        temp = strstr(pStrSrc, pStrOtsOk);
		if ( temp != NULL) {
            temp += strlen("Mode=");
            sscanf(temp, "%hhd", &startup);
            sf_set_power_on_mode(startup);
            //printf("%s: PowerOnModeStr=%d\r\n", __func__,startup);
			//printf("%s: temp=%s\r\n", __func__,temp);
		}
        temp = strstr(pStrSrc, pStrUpFw);
		if ( temp != NULL) {
            temp += strlen("UpFw=");
            sscanf(temp, "%hhd", &UpFw);
            //printf("%s: UpFw=%d\r\n", __func__,UpFw);
            sf_set_fw_update(UpFw);
		}
        temp = strstr(pStrSrc, pStrUpMcu);
		if ( temp != NULL) {
            temp += strlen("mcu=");
            sscanf(temp, "%hhd", &Upmcu);
            sf_set_mcu_update_flag(Upmcu);
		}
        temp = strstr(pStrSrc, pStrSF);
		if ( temp != NULL) {
            temp += strlen("sf=");
            sscanf(temp, "%hhd", &sftmp);
            sf_cardv_battery_level_set(sftmp);
		}
        SLOGI("StartMode=%d,UpFw=%d Upmcu=%d sftmp=%d\r\n", startup, UpFw, Upmcu, sftmp);
		free(pStrSrc);
	}

	fclose(fp);
	fp  = NULL;
	pStrSrc = NULL;
	u32ize = 0;

	return startup;
}
#endif

int NvtMain(void)
{
    #if HUNTING_CAMERA_MCU == ENABLE
    sf_cardv_check_power_on_mode();
    sf_cardv_load_menu_info_start();
    #endif
	System_InstallID();
#if (USB_MODE==ENABLE)
	System_OnUsbPreInit();
#endif
	System_OnPowerPreInit();

    #if HUNTING_CAMERA_MCU != ENABLE// The time is controlled by the MCU. sf_get_mcu_rtc_set_sys
	//System_OnPowerPreInit() should be prior to rtc checking
	struct tm ctv = {0};
	ctv = hwclock_get_time(TIME_ID_CURRENT);
	if(ctv.tm_year < DEFAULT_YEAR) {
		ctv.tm_year = DEFAULT_YEAR;
		ctv.tm_mon = DEFAULT_MON;
		ctv.tm_mday = DEFAULT_DAY;
		ctv.tm_hour = DEFAULT_HOUR;
		ctv.tm_min = DEFAULT_MIN;
		ctv.tm_sec = DEFAULT_SEC;
		hwclock_set_time(TIME_ID_CURRENT, ctv, 0);
	}
    #endif

#if (POWERON_TRACE == ENABLE)
	System_WaitForPowerOnFinish();  // Wait for boot cmd
#endif
	Dx_InitIO();
	SxTimer_Open(); //start sxtimer task
	System_OnTimerInit();
#if (USB_MODE==ENABLE)
	System_OnUsbInit();
#endif
	nvt_hdal_init();
	nvt_user_init();
	#if HUNTING_CAMERA_MCU == ENABLE
    sf_log_Level_set(SF_LOG_LEVEL_DEBUG);
    //sf_cardv_check_power_on_mode();
    BOOL inUsb = GxUSB_GetIsUSBPlug();
    // if(TRUE == inUsb)//(!sf_gpio_get_status(GPIO_INT_USBPLUGIN))
	// {
    //     sf_usb_mux_s(0);
    //     sf_sys_status_led_set(SF_LED_SYS_STATE_USB_IN);
    // }
    #if HUNTING_CAMERA_4G == ENABLE

    sf_share_mem_file_init();
    /*if (cardv_message_queue_init())
    {
        printf("cardv initial message queue error!\n");
        exit(1);
    }*/
    if(SF_SUCCESS == sf_com_message_cardv_init())
    {
        printf("create message successs!!!!\n");
    }
    if(SF_SUCCESS == sf_com_message_app_init())
    {
        printf("create cardv message successs!!!!\n");
    }
    sf_cardv_message_thread_init();
#if USE_MMC_DEV_CHECK
	sf_mmc_dev_check_start();
#endif    
    SF_MESSAGE_BUF_S stMessageBuf = {0};

    /*if(!sf_gpio_get_status(GPIO_KEY_TEST)){
        sf_set_fw_update(1);//update
    }*/
    if(TRUE != inUsb)
	{
        stMessageBuf.arg1 = SF_MCU_CMD_POWERON;
        stMessageBuf.cmdId = CMD_MCU;
        sf_com_message_send_to_app(&stMessageBuf);

        // stMessageBuf.arg1 = SF_DEV_CMD_BAT;
        // stMessageBuf.cmdId = CMD_DEV;
        // sf_com_message_send_to_app(&stMessageBuf);
        
        stMessageBuf.arg1 = SF_DEV_CMD_TEMPER;
        stMessageBuf.cmdId = CMD_DEV;
        sf_com_message_send_to_app(&stMessageBuf);
    }
    #else
    sf_mcu_init();
    sf_get_power_on_mode();
    sf_mcu_wdg_set(30);        
    sf_usb_mux_s(1);
    /*led init*/
    sf_led_init();
    #endif
    sf_sd_exist_reg_cb(DrvCARD_DetStrgCard);
	#endif

	System_WaitForPowerOffStart();  // Wait for shutdown cmd
    sf_log_sava();
	nvt_user_uninit();
	nvt_hdal_uninit();

	System_OnPowerPostExit(); //never return
	return 0;
}