#include <string.h>
#include <plat/sdio.h>
#include <plat/strg_def.h>
#include <hdal.h>
#include <FileSysTsk.h>
#include "sys_filesys.h"
#include "sys_mempool.h"
#include "FileDB.h"
#include "gpio.h"
#include <FreeRTOS.h>
#include <task.h>
#include "sys_fastboot.h"
#include "PrjCfg.h"
#include "DxHunting.h"
#include <kwrap/debug.h>
#if HUNTING_CAMERA_MCU == ENABLE
#include "PrjInc.h"
#include "wdt.h"
#include <sf_mcu.h>
#endif
#if (HUNTING_CAMERA_MODEL == ENABLE)

#include "IOCfg.h"

#define GPIO_CARD_INSERT_LEVEL			(FALSE)		// low active
#define MAX_OPENED_FILE_NUM 10

static THREAD_HANDLE task_hdl;

static void card_insert_job(void)
{
	UINT32 uiPoolAddr;
	int    ret;

	FILE_TSK_INIT_PARAM     Param = {0};
	FS_HANDLE               StrgDXH, StrgDXH2;

	printf("filesys_init b\r\n");
	memset(&Param, 0, sizeof(FILE_TSK_INIT_PARAM));
#if defined(_EMBMEM_EMMC_)
	StrgDXH = (FS_HANDLE)sdio3_getStorageObject(STRG_OBJ_FAT1);
#else
	StrgDXH = (FS_HANDLE)sdio_getStorageObject(STRG_OBJ_FAT1);
#endif

#if	FS_MULTI_STRG_FUNC
	StrgDXH2 = (FS_HANDLE)sdio2_getStorageObject(STRG_OBJ_FAT1);


	DBG_WRN("sdio2_getStorageObject\n");
	{
    	UINT32 totoal_sectors = 0;
//	    UINT32 uiPhyAddr = 0;
//		UINT32 uiPhySize = 0;
//		unsigned long long partition_ofs= 0, partition_size = 0;
//		unsigned long long usr_area_size = 0;
    	STORAGE_OBJ* pStrg = sdio2_getStorageObject(STRG_OBJ_FAT1);
//    	void *strg_mem = malloc(0x300);

//    	pStrg->SetParam(STRG_SET_MEMORY_REGION, (UINT32)strg_mem, 0x300);
    	pStrg->Open(); //for initial emmc speed up, should open first, and then set partition
    	pStrg->GetParam(STRG_GET_DEVICE_PHY_SECTORS, (UINT32)&totoal_sectors, 0);
    	if (totoal_sectors == 0) {
    		DBG_WRN("totoal_sectors couldn't be zero\n");
    	}

		DBG_WRN("storage_partition_init: totoal_sectors = %d\r\n", totoal_sectors);
    	pStrg->SetParam(STRG_SET_PARTITION_SECTORS, 16, totoal_sectors - 16);
//    	pStrg->Close();

		//set the FAT size
//		ret = storage_get_partition_addr(&partition_ofs, &partition_size, PARTITION_PATH_ROOTFSL1);
//        usr_area_size = (unsigned long long)totoal_sectors*(unsigned long long)_EMBMEM_BLK_SIZE_;
//		uiPhyAddr = partition_ofs/_EMBMEM_BLK_SIZE_;
//		uiPhySize = (usr_area_size - partition_ofs)/_EMBMEM_BLK_SIZE_;
//		if (ret == 0) {
//		pStrg = EMB_GETSTRGOBJ(STRG_OBJ_FW_FAT);
//		pStrg->SetParam(STRG_SET_MEMORY_REGION, (UINT32)strg_mem, STRG_MEM_SIZE);
//		pStrg->SetParam(STRG_SET_PARTITION_SECTORS, uiPhyAddr, uiPhySize);
//		} else {
//			DBG_ERR("Cat get the %s path info\r\n", PARTITION_PATH_ROOTFSL1);
//		}
	}


#endif


	uiPoolAddr = mempool_filesys;
	Param.FSParam.WorkBuf = uiPoolAddr;
	Param.FSParam.WorkBufSize = (POOL_SIZE_FILESYS);
	// support exFAT
	Param.FSParam.bSupportExFAT   = TRUE;
	//Param.pDiskErrCB = (FileSys_CB)Card_InitCB;
	strncpy(Param.FSParam.szMountPath, "/mnt/sd", sizeof(Param.FSParam.szMountPath) - 1); //only used by FsLinux
	Param.FSParam.szMountPath[sizeof(Param.FSParam.szMountPath) - 1] = '\0';
	Param.FSParam.MaxOpenedFileNum = MAX_OPENED_FILE_NUM;
	if (FST_STA_OK != FileSys_Init(FileSys_GetOPS_uITRON())) {
		DBG_WRN("FileSys_Init failed\r\n");
	}
	ret = FileSys_OpenEx('A', StrgDXH, &Param);
	if (FST_STA_OK != ret) {
		DBG_WRN("FileSys_Open err %d\r\n", ret);
	}
	// call the function to wait init finish
	FileSys_WaitFinishEx('A');
    FileSys_SetParamEx('A', FST_PARM_UPDATE_FSINFO , TRUE);
#if HUNTING_CAMERA_MCU == ENABLE
    if(TRUE == sf_check_card_full())
    {
    	DBG_WRN("ERR card full\r\n");
        fastboot_set_done(BOOT_INIT_FILESYSOK);
    }
    else
    {
        fastboot_set_done(BOOT_INIT_FILESYSOK);
        // sf_log_confg();
        // sf_log_open();
    }
#endif

#if	FS_MULTI_STRG_FUNC
	uiPoolAddr = mempool_filesys + POOL_SIZE_FILESYS;
	Param.FSParam.WorkBuf = uiPoolAddr;
	Param.FSParam.WorkBufSize = (POOL_SIZE_FILESYS);
	// support exFAT
	Param.FSParam.bSupportExFAT   = FALSE;
	//Param.pDiskErrCB = (FileSys_CB)Card_InitCB;
	strncpy(Param.FSParam.szMountPath, "/mnt/sd2", sizeof(Param.FSParam.szMountPath) - 1); //only used by FsLinux
	Param.FSParam.szMountPath[sizeof(Param.FSParam.szMountPath) - 1] = '\0';
	Param.FSParam.MaxOpenedFileNum = MAX_OPENED_FILE_NUM;
//	if (FST_STA_OK != FileSys_Init(FileSys_GetOPS_uITRON())) {
//		printf("FileSys_Init failed\r\n");
//	}
	DBG_WRN("Open B:\n");
	ret = FileSys_OpenEx('B', StrgDXH2, &Param);
	if (FST_STA_OK != ret) {
		printf("FileSys_Open err %d\r\n", ret);
	}
	// call the function to wait init finish
	FileSys_WaitFinishEx('B');
//    FileSys_SetParamEx('B', FST_PARM_UPDATE_FSINFO , TRUE);
#endif

	//fastboot_set_done(BOOT_INIT_FILESYSOK);
    DBG_WRN("filesys_init e\r\n");
}

#if !defined(_EMBMEM_EMMC_)
static void card_remove_job(void)
{
	FileSys_WaitFinishEx('A');
	FileSys_CloseEx('A', FST_TIME_INFINITE);
}
#endif

static void sys_detect_card_task(void)
{
#if defined(_EMBMEM_EMMC_)
	THREAD_ENTRY();

	card_insert_job();

	THREAD_RETURN(0);
#else
	UINT32 old_detect;
	UINT32 card_det_tsk_run = 1;

	THREAD_ENTRY();

	// force 1st time card detect
	old_detect = !GPIO_CARD_INSERT_LEVEL;

	//coverity[no_escape]
	while (card_det_tsk_run) {
		UINT32 curr_detect;

		curr_detect= gpio_getPin(GPIO_CARD_DETECT);
		if (old_detect != curr_detect) {
			if (curr_detect == GPIO_CARD_INSERT_LEVEL) {
				printf("%s: Card Insert\r\n", __func__);
				card_insert_job();
				card_det_tsk_run = 0;
			} else {
				printf("%s: Card Remove\r\n", __func__);
				card_remove_job();
			}
		}

		old_detect = curr_detect;

		vTaskDelay(pdMS_TO_TICKS(1000));
	}

	THREAD_RETURN(0);
#endif
}
#endif

void filesys_init(void)
{
#if 0
	UINT32 uiPoolAddr;
	int    ret;

	FILE_TSK_INIT_PARAM     Param = {0};
	FS_HANDLE               StrgDXH;

	printf("filesys_init b\r\n");
	memset(&Param, 0, sizeof(FILE_TSK_INIT_PARAM));
	StrgDXH = (FS_HANDLE)sdio_getStorageObject(STRG_OBJ_FAT1);

	uiPoolAddr = mempool_filesys;
	Param.FSParam.WorkBuf = uiPoolAddr;
	Param.FSParam.WorkBufSize = (POOL_SIZE_FILESYS);
	// support exFAT
	Param.FSParam.bSupportExFAT   = TRUE;
	//Param.pDiskErrCB = (FileSys_CB)Card_InitCB;
	strncpy(Param.FSParam.szMountPath, "/mnt/sd", sizeof(Param.FSParam.szMountPath) - 1); //only used by FsLinux
	Param.FSParam.szMountPath[sizeof(Param.FSParam.szMountPath) - 1] = '\0';
#endif

	FileSys_InstallID(FileSys_GetOPS_uITRON());

#if (HUNTING_CAMERA_MODEL == ENABLE)
	if(DrvGPIO_GetHuntingWorkMode() != HUNTING_NORMAL_MODE){
		task_hdl = vos_task_create(sys_detect_card_task,  0, "SysDetectCard",   12,  4096);
		vos_task_resume(task_hdl);
	}
#endif	
	
#if 0
	if (FST_STA_OK != FileSys_Init(FileSys_GetOPS_uITRON())) {
		printf("FileSys_Init failed\r\n");
	}
	ret = FileSys_OpenEx('A', StrgDXH, &Param);
	if (FST_STA_OK != ret) {
		printf("FileSys_Open err %d\r\n", ret);
	}
	// call the function to wait init finish
	FileSys_WaitFinishEx('A');
	printf("filesys_init e\r\n");
#endif
	FileDB_InstallID();
}
#if HUNTING_CAMERA_MCU == ENABLE

static int SF_SX_TIMER_DET_SYSTEM_ERROR_ID = -1;
_ALIGNED(64) static CHAR gLogFile_Buff[LOGFILE_BUFFER_SIZE]= {0};

void sfSystem_DetErr(void);
SX_TIMER_ITEM(sfSystem_DetErr,  sfSystem_DetErr,50, FALSE)

void sfSystem_DetErr(void)
{

}
void sf_log_confg(void)
{
    #if (LOGFILE_FUNC==ENABLE)
    UIMenuStoreInfo *puiPara = sf_ui_para_get();
    if(puiPara->DebugMode)
	{
		LOGFILE_CFG   cfg = {0};
		cfg.ConType = LOGFILE_CON_UART|LOGFILE_CON_STORE;
		cfg.TimeType = LOGFILE_TIME_TYPE_DATETIME;
		cfg.LogBuffAddr = (UINT32)gLogFile_Buff;
		cfg.LogBuffSize = sizeof(gLogFile_Buff);

		LogFile_Config(&cfg);

        SF_SX_TIMER_DET_SYSTEM_ERROR_ID = SxTimer_AddItem(&Timer_sfSystem_DetErr);

	}
    #endif
}

void sf_log_open(void)
{
#if (LOGFILE_FUNC==ENABLE)

    UIMenuStoreInfo *puiPara = sf_ui_para_get();

    if ((puiPara->DebugMode) && SxTimer_GetFuncActive(SF_SX_TIMER_DET_SYSTEM_ERROR_ID) == 0)
    {
        LOGFILE_OPEN    logOpenParm = {0};
        UINT32          maxFileNum = 32;
        UINT32          maxFileSize = 0x100000; // 1MB
        CHAR            rootDir[LOGFILE_ROOT_DIR_MAX_LEN + 1] = "A:\\LOG\\";
        #if defined(_CPU2_LINUX_)
        CHAR            rootDir2[LOGFILE_ROOT_DIR_MAX_LEN + 1] = "A:\\Novatek\\LOG2\\";
        #endif
        CHAR            sysErrRootDir[LOGFILE_ROOT_DIR_MAX_LEN + 1] = "A:\\SYS\\";

        logOpenParm.maxFileNum = maxFileNum;
        logOpenParm.maxFileSize = maxFileSize;
        logOpenParm.isPreAllocAllFiles = FALSE;
        logOpenParm.isSaveLastTimeSysErrLog  = wdt_getResetNum()>0 ? TRUE : FALSE;
        logOpenParm.lastTimeSysErrLogBuffAddr = mempool_logfile;
        logOpenParm.lastTimeSysErrLogBuffSize = POOL_SIZE_LOGFILE;
        logOpenParm.isZeroFile = TRUE;
        strncpy(logOpenParm.rootDir, rootDir, LOGFILE_ROOT_DIR_MAX_LEN);
        #if defined(_CPU2_LINUX_)
        strncpy(logOpenParm.rootDir2, rootDir2, LOGFILE_ROOT_DIR_MAX_LEN);
        #endif
        strncpy(logOpenParm.sysErrRootDir, sysErrRootDir, LOGFILE_ROOT_DIR_MAX_LEN);
        LogFile_Open(&logOpenParm);

        //start scan
        SxTimer_SetFuncActive(SF_SX_TIMER_DET_SYSTEM_ERROR_ID, TRUE);
        sf_para_print();
    }
#endif
}

#endif