#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/vfs.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <ctype.h>
#include <dirent.h>
#include <memory.h>
#include "DCF.h"
#include "sf_type.h"
#include "sf_log.h"

#include "SF_SysStrgMng.h"
#include <sf_param_common.h>
#include <sf_param_struct.h>
#include <FileSysTsk.h>
#include "sf_mcu.h"
#if (USE_DCF == ENABLE)
#include "DCF.h"
#endif
#include "kwrap/flag.h"
#include "kwrap/debug.h"
#include "kwrap/util.h"

#if HUNTING_CAMERA_MCU == ENABLE
#include <sf_message_queue.h>
#include "sf_sd_common.h"
#endif

typedef struct
{
	int event;
	int dev_id;
	int mounted_status;
}STRG_CB_PARAM;


SF_THREAD_S MMCMonitorTskCfg =
{
    .IsRun = 0,
    .TskId = -1,
};

#define MIN_DISK_FREE_SIZE_MB 300
#define MIN_FREE_SIZE_MB 30


SF_ST_MMC_DEV *sf_mmc_dev[MMC_DEV_MAX_NUM] = {NULL};

SF_ST_MMC_DEV *pMMCDev = NULL;

static ID sf_dev_flag_id = 0;

void sf_dev_flag_init(void)
{
    ER ret = E_OK;
    T_CFLG cflg;
    if ((ret |= vos_flag_create(&sf_dev_flag_id, &cflg, "sf_dev_flag_id")) != E_OK)
    {
		SYS_SLOGE("sf_dev_flag_id fail\r\n");
	}
	vos_flag_clr(sf_dev_flag_id, (FLGPTN)-1);
}

void sf_dev_flag_set_done(DEV_FLAG_INIT boot_init)
{
	vos_flag_set(sf_dev_flag_id, (FLGPTN)(1 << boot_init));
}

void sf_dev_flag_wait_done(DEV_FLAG_INIT boot_init)
{
	FLGPTN flgptn;
	vos_flag_wait(&flgptn, sf_dev_flag_id, (FLGPTN)(1 << boot_init), TWF_ANDW);
}

int sf_dev_flag_wait_done_timeout(DEV_FLAG_INIT boot_init, int timeout_ms)
{
	ER ret = E_OK;
	FLGPTN flgptn;

	ret = vos_flag_wait_timeout(&flgptn, sf_dev_flag_id, (FLGPTN)(1 << boot_init), TWF_ANDW, vos_util_msec_to_tick(timeout_ms));
	if(unlikely(ret != E_OK)){
		printf("wait(%lu) init timeout(%ld ms)!\n", boot_init, timeout_ms);
	}

	return ret;
}

void sf_dev_flag_clear_done(DEV_FLAG_INIT boot_init)
{
	//vos_flag_clr(sf_mcu_flag_id, (FLGPTN)(1 << boot_init));
	vos_flag_clr(sf_dev_flag_id, (FLGPTN)-1);
}

void SF_SetMMCDev(SF_ST_MMC_DEV *pDev)
{
	if(pDev == NULL)
	{
		return;
	}
	
	pMMCDev = pDev;
}

SF_ST_MMC_DEV *SF_GetMMCDev(void)
{
	if(pMMCDev == NULL)
	{
		return NULL;
	}
	return pMMCDev;
}

void SF_StrgInit(void) {
    for (int i = 0; i < MMC_DEV_MAX_NUM; i++) {
        sf_mmc_dev[i] = (SF_ST_MMC_DEV *)malloc(sizeof(SF_ST_MMC_DEV));
        if (sf_mmc_dev[i] == NULL) {
            MLOGD("SF_StrgInit Failed, id = %d\n", i);
            // Handle malloc failure
            exit(EXIT_FAILURE);
        }
        sf_mmc_dev[i]->dcf_handle = -1;
        sf_mmc_dev[i]->dev_type = MMC_DEV_NO;
        sf_mmc_dev[i]->node = MMC_DEV_NODE_STATE_NO_EXIST;
        sf_mmc_dev[i]->moumted_state = MMC_DEV_MOUNT_STATE_UNMOUNTED;
        sf_mmc_dev[i]->space_state = MMC_DEV_SPACE_STATE_ENOUGH;
        sf_mmc_dev[i]->loop_state = MMC_DEV_LOOP_STATE_OFF;
    }
    sf_strg_dev_init();
	pMMCDev = (SF_ST_MMC_DEV *)malloc(sizeof(SF_ST_MMC_DEV));
}

void SF_StrgUnInit(void)
{
    for(int i = 0; i < MMC_DEV_MAX_NUM; i++)
    {
        if(sf_mmc_dev[i] != NULL) {
            free(sf_mmc_dev[i]);
            sf_mmc_dev[i] = NULL;
        }
    }
	
	if(pMMCDev != NULL)
	{
		free(pMMCDev);
		pMMCDev = NULL;
	}
}

int SF_GetMMCDevHandle(MMC_DEV_TYPE dev_type)
{
	if(sf_mmc_dev != NULL) {
		return sf_mmc_dev[dev_type]->dcf_handle;
	}
	return 0;
}

void SF_StrgSetDcfHandle(UINT32 strg_id, UINT32 handle)
{
	sf_mmc_dev[strg_id]->dcf_handle = handle;
}

static UINT32 SF_StrgSpaceCheckFull(MMC_DEV_TYPE mmc_dev)
{
	UINT64 diskFree = 0;
    UINT32 ret = 0;
	UIMenuStoreInfo *puiPara = sf_ui_para_get();
    #if HUNTING_CAMERA_MCU == ENABLE
    if(sf_get_power_off_flag() || sf_is_usb_flag())
	{
		return ret;
	}
    #endif
    /*check disk free size*/
	if((mmc_dev == MMC_DEV_SD) && (sf_in_card_exist() == TRUE))
	{
		diskFree = FileSys_GetDiskInfoEx('A', FST_INFO_FREE_SPACE);
	}
	else if((mmc_dev == MMC_DEV_EMMC) && (sf_in_emmc_exist()))
	{
		diskFree = FileSys_GetDiskInfoEx('B', FST_INFO_FREE_SPACE);
	}
    diskFree = diskFree/1024/1024;
    
    if(diskFree < MIN_FREE_SIZE_MB) /* 30MB*/
    {
        ret = 1;
        if(mmc_dev == MMC_DEV_SD){
            sf_set_sd_card_full(1);
        }
        else {
            sf_set_emmc_card_full(1);
        }
    }
    else
    {
        ret = 0;
        if(mmc_dev == MMC_DEV_SD){
            sf_set_sd_card_full(0);
        }
        else {
            sf_set_emmc_card_full(0);
        }
    }
	
	if(sf_mmc_dev != NULL) {
		sf_mmc_dev[mmc_dev]->space_state = ret == 0 ? MMC_DEV_SPACE_STATE_ENOUGH : MMC_DEV_SPACE_STATE_NO_ENOUGH; 
	}
	
	for(int i = 0; i < MMC_DEV_MAX_NUM; i++)
	{
		sf_mmc_dev[i]->loop_state = puiPara->SdLoopSwitch == 1 ? MMC_DEV_LOOP_STATE_ON : MMC_DEV_LOOP_STATE_OFF;
	}
    //MLOGD("[%s:%d]sd card diskFree=%lluM\n", __FUNCTION__, __LINE__, diskFree);
    return ret;
}

static int SF_StrgNodeCheck(const char *devName)
{
	int tryCnt = 200;
	int ret = access(devName, F_OK);
	while (ret != 0  && tryCnt--)
	{
		usleep(10*1000);
		ret = access(devName, F_OK);
	}

	if (tryCnt < 0)
	{
		printf("no found %s\n", devName);
		return -1;
	}
	return ret;
}

void SF_StrgRegister(SF_MESSAGE_BUF_S *pMessageBuf)
{
	MLOGD("[dev_id:%d, evt:%d]\n",pMessageBuf->arg2, pMessageBuf->arg1);
	UIMenuStoreInfo *puiPara = sf_ui_para_get();

	if(pMessageBuf->arg2 == MMC_DEV_SD)
	{
		if(pMessageBuf->arg1 == CMD_SD_STRG_CB_INSERTED)
		{
			sf_mmc_dev[MMC_DEV_SD]->node = MMC_DEV_NODE_STATE_EXIST;
		}
		else if(pMessageBuf->arg1 == CMD_SD_STRG_CB_REMOVED)
		{
			sf_mmc_dev[MMC_DEV_SD]->node = MMC_DEV_NODE_STATE_NO_EXIST;
		}
		else if(pMessageBuf->arg1 == CMD_SD_STRG_CB_MOUNT_FINISH)
		{
			sf_mmc_dev[MMC_DEV_SD]->moumted_state = MMC_DEV_MOUNT_STATE_MOUNTED;
		}
		else if(pMessageBuf->arg1 == CMD_SD_STRG_CB_UNMOUNT_FINISH)
		{
			sf_mmc_dev[MMC_DEV_SD]->moumted_state = MMC_DEV_MOUNT_STATE_UNMOUNTED;
		}

	}
	else if(pMessageBuf->arg2 == MMC_DEV_EMMC)
	{
		if(SF_StrgNodeCheck(EMMC_DEVICE_NAME) == 0)
		{
			sf_mmc_dev[MMC_DEV_EMMC]->node = MMC_DEV_NODE_STATE_EXIST;
		}
		else
		{
			sf_mmc_dev[MMC_DEV_EMMC]->node = MMC_DEV_NODE_STATE_NO_EXIST;
            sf_set_emmc_err(1);
		}

		if(pMessageBuf->arg1 == CMD_SD_STRG_CB_MOUNT_FINISH)
		{
			sf_mmc_dev[MMC_DEV_EMMC]->moumted_state = MMC_DEV_MOUNT_STATE_MOUNTED;
            sf_set_emmc_err(0);
		}
		else if(pMessageBuf->arg1 == CMD_SD_STRG_CB_UNMOUNT_FINISH)
		{
			sf_mmc_dev[MMC_DEV_EMMC]->moumted_state = MMC_DEV_MOUNT_STATE_UNMOUNTED;
            sf_set_emmc_err(1);
		}
	}

	for(int i = 0; i < MMC_DEV_MAX_NUM; i++)
	{
		MLOGD("node:%d, mount:%d, loop:%d\n", 
				sf_mmc_dev[i]->node, sf_mmc_dev[i]->moumted_state, puiPara->SdLoopSwitch);
	}
}

SF_ST_MMC_DEV *SF_StrgCheckWorkableDev(void)
{
	MMC_DEV_TYPE workable_dev = MMC_DEV_NO;
	UIMenuStoreInfo *puiPara = sf_ui_para_get();
	//MLOGD("sf mmc check workable dev start!!!\n");
	
	if((sf_mmc_dev[MMC_DEV_SD]->node == MMC_DEV_NODE_STATE_NO_EXIST) &&
		(sf_mmc_dev[MMC_DEV_EMMC]->node == MMC_DEV_NODE_STATE_NO_EXIST))
	{
		workable_dev = MMC_DEV_NO;
	}
	else if(sf_mmc_dev[MMC_DEV_EMMC]->node == MMC_DEV_NODE_STATE_NO_EXIST)   	   //EMMC节点不存在
	{
		if(sf_mmc_dev[MMC_DEV_SD]->moumted_state == MMC_DEV_MOUNT_STATE_MOUNTED)
		{
			if(!SF_StrgSpaceCheckFull(MMC_DEV_SD))
			{
				workable_dev = MMC_DEV_SD;
			}
			else
			{
				if((puiPara->SdLoopSwitch == 1) && (!sf_get_mode_flag()))
				{
					workable_dev = MMC_DEV_SD;
				}
			}
		}
	}
	else if(sf_mmc_dev[MMC_DEV_SD]->node == MMC_DEV_NODE_STATE_NO_EXIST)    //SD节点不存在
	{
		if(sf_mmc_dev[MMC_DEV_EMMC]->moumted_state == MMC_DEV_MOUNT_STATE_MOUNTED)
		{
			if(!SF_StrgSpaceCheckFull(MMC_DEV_EMMC))
			{
				workable_dev = MMC_DEV_EMMC;
			}
			else
			{
				if((puiPara->SdLoopSwitch == 1) && (!sf_get_mode_flag()))
				{
					workable_dev = MMC_DEV_EMMC;
				}
			}
		}
	}
	else 																	//MMC节点都存在
	{
		if((sf_mmc_dev[MMC_DEV_SD]->moumted_state == MMC_DEV_MOUNT_STATE_UNMOUNTED) &&
			(sf_mmc_dev[MMC_DEV_EMMC]->moumted_state == MMC_DEV_MOUNT_STATE_UNMOUNTED))
		{
			workable_dev = MMC_DEV_NO;
		}
        else if(sf_mmc_dev[MMC_DEV_SD]->moumted_state == MMC_DEV_MOUNT_STATE_UNMOUNTED)
        {
           if(!SF_StrgSpaceCheckFull(MMC_DEV_EMMC))
            {
                workable_dev = MMC_DEV_EMMC;
            }
            else
            {
                if((puiPara->SdLoopSwitch == 1) && (!sf_get_mode_flag()))
                {
                    workable_dev = MMC_DEV_EMMC;
                }
            }
        }
        else if(sf_mmc_dev[MMC_DEV_EMMC]->moumted_state == MMC_DEV_MOUNT_STATE_UNMOUNTED)
        {
            if(!SF_StrgSpaceCheckFull(MMC_DEV_SD))
            {
                workable_dev = MMC_DEV_SD;
            }
            else
            {
                if((puiPara->SdLoopSwitch == 1) && (!sf_get_mode_flag()))
                {
                    workable_dev = MMC_DEV_EMMC;
                }
            }
        }
        else
        {
            if(!SF_StrgSpaceCheckFull(MMC_DEV_SD) &&
               !SF_StrgSpaceCheckFull(MMC_DEV_EMMC))
            {
                workable_dev = MMC_DEV_EMMC;
            }
            else if(!SF_StrgSpaceCheckFull(MMC_DEV_EMMC))
            {
                workable_dev = MMC_DEV_EMMC;
            }
            else if(!SF_StrgSpaceCheckFull(MMC_DEV_SD))
            {
                workable_dev = MMC_DEV_SD;
            }
            else
            {
                if((puiPara->SdLoopSwitch == 1) && (!sf_get_mode_flag()))
                {
                    workable_dev = MMC_DEV_EMMC;
                }
            }
        }
	}
	
	if(workable_dev == MMC_DEV_NO)
	{
		//MLOGD("Strg Check, No dev can use\n");
		return NULL;
	}
	else
	{
		sf_mmc_dev[workable_dev]->dev_type = workable_dev;
		//MLOGD("Strg Check, workable_dev = %d\n", workable_dev);
		SF_SetMMCDev(sf_mmc_dev[workable_dev]);
		
		if(workable_dev == MMC_DEV_SD)
			DCF_SetFileFreeChars(DCF_FILE_TYPE_ANYFORMAT, SF_SD_DCF_FILE_NAME);
		else if(workable_dev == MMC_DEV_EMMC)
			DCF_SetFileFreeChars(DCF_FILE_TYPE_ANYFORMAT, SF_EMMC_DCF_FILE_NAME);	
		
		return sf_mmc_dev[workable_dev];
	}
}

static int sfStrgOnActionSendCurrentDev(SF_ST_MMC_DEV *pMMCDev)
{
	SF_MESSAGE_BUF_S stMessageBuf = {0};
	stMessageBuf.arg1 = CMD_SD_STRG_WORKABLE_DEV;
	stMessageBuf.arg2 = pMMCDev->dev_type;
	stMessageBuf.arg3 = pMMCDev->moumted_state;
	stMessageBuf.cmdId = CMD_SD;
    sf_strg_dev_register(pMMCDev->dev_type, pMMCDev->moumted_state);
	sf_com_message_send_to_app(&stMessageBuf);
	MLOGD("sf sys strg update current dev!\n");
	return 0;
}

static void* mmc_monitoring_thread(void *arg)
{
	static MMC_DEV_TYPE current_id = MMC_DEV_NO;
	while(MMCMonitorTskCfg.IsRun)
	{
        sf_dev_flag_wait_done_timeout(DEV_FLAG_INIT_FILENAMINGOK, 5000);
		pMMCDev = SF_StrgCheckWorkableDev();

		if(pMMCDev != NULL)	{		
			if(current_id != pMMCDev->dev_type)
			{
				current_id = pMMCDev->dev_type;
				MLOGD("mmc monitor dev has changed!, %d\n", pMMCDev->dev_type);
				sfStrgOnActionSendCurrentDev(pMMCDev);
			}
		}
			
		sf_sleep_ms(1000);
	}
	return NULL;
}

int sf_mmc_dev_check_start(void)
{
	SF_StrgInit();// 初始化sf_mmc设备Obj
    sf_dev_flag_init();
	int ret = pthread_create(&MMCMonitorTskCfg.TskId, NULL, mmc_monitoring_thread, NULL);
	if(ret != SF_SUCCESS)
	{
		MLOGD("thread sf_mmc_monitoring_start creat fail!\n");
		return ret;
	}
	MMCMonitorTskCfg.IsRun = 1;
	MLOGD("mmc_dev check create success!\n");
	return 0;
}

void sf_file_sys_int_status(void)
{
	MLOGD("s\n");

	SF_MESSAGE_BUF_S stMessageBuf = {0};
	stMessageBuf.arg1 = CMD_SD_FILESYS_INIT_STATUS;
	stMessageBuf.cmdId = CMD_SD;
	sf_com_message_send_to_app(&stMessageBuf);
    sf_thumb_dir();
}

void sf_thumb_dir(void)
{
	MLOGD("s\n");
	char thumb_dir[128] = {'\0'};

	sprintf(thumb_dir, "%c%s", 'A', PHOTO_THUMB_PATH);
	FileSys_MakeDir(thumb_dir);

#if SF_IQ_TEST != ENABLE
	FileSys_SetAttrib(thumb_dir, FST_ATTRIB_HIDDEN/* | FST_ATTRIB_SYSTEM*/, TRUE);
#endif

#if	FS_MULTI_STRG_FUNC
	sprintf(thumb_dir, "%c%s", 'B', PHOTO_THUMB_PATH);
	FileSys_MakeDir(thumb_dir);
#if SF_IQ_TEST != ENABLE
	FileSys_SetAttrib(thumb_dir, FST_ATTRIB_HIDDEN/* | FST_ATTRIB_SYSTEM*/, TRUE);
#endif
#endif
}