/**************************************************************************
 *
 *       Copyright (c) 2009-2018 by SiFar Technology, Inc.
 *
 *  This software is copyrighted by and is the property of SiFar
 *  Technology, Inc.. All rights are reserved by SiFar Technology, Inc..
 *  This software may only be used in accordance with the corresponding
 *  license agreement. Any unauthorized use, duplication, distribution,
 *  or disclosure of this software is expressly forbidden.
 *
 *  This Copyright notice MUST not be removed or modified without prior
 *  written consent of SiFar Technology, Inc..
 *
 *  SiFar Technology, Inc. reserves the right to modify this software without notice.
 *
 *  Author: Payton
 *  Ver: 1.0.0  2023.02.14
 *  Description: sd code
 *
**************************************************************************/


//#include <linux/module.h>
#include <sf_mcu.h>
#include <stdio.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
//#include <linux/input.h>

#include <sys/fcntl.h> 
#include <sys/stat.h>
//#include <sys/ioctl.h>      
#include <unistd.h>     
#include <stdio.h>
#include <stdlib.h>

#include <kwrap/util.h>
#include <sys/wait.h>
#include <errno.h>
#include <kwrap/debug.h>
#include <time.h>
//#include <io/gpio.h>
#include "UIInfo/UIInfo.h"
#include <FileSysTsk.h>
#include "sf_sd_common.h"

static BOOL IsCardFull = FALSE;
SF_CALLBACK_SD_CMD g_fpSd_Exist_CB = NULL;
extern BOOL DrvCARD_DetStrgCard(void);

SF_RTOS_ST_MMC_DEV *sf_rtos_mmc_dev[MMC_DEV_MAX_NUM] = {NULL};

BOOL sf_is_card_full(void)
{
	//printf("[%s]:%d IsCardFull:%d\n", __FUNCTION__, __LINE__, IsCardFull);
	return IsCardFull;
}

UINT32 sf_check_card_full(void)
{
    UINT64 diskFree = 0;
    UINT32 ret = 0;
        
    //UIMenuStoreInfo *puiPara = sf_ui_para_get();
    if(!sf_in_card_exist())
    {
        return 1;
    }

    /*check disk free size*/
    diskFree = FileSys_GetDiskInfo(FST_INFO_FREE_SPACE);
    diskFree = diskFree/1024/1024;
    
    if(diskFree < 30) /* 30MB */
    {
            ret = TRUE;
            //if(0 == puiPara->SdLoopSwitch)
            {
                    IsCardFull = TRUE;
            }
            //printf("%s:%d sd card is full diskFree=%lu",__FUNCTION__,__LINE__,diskFree);
    }
    else
    {
            ret = FALSE;
            //printf("%s:%d sd card no full diskFree=%lu",__FUNCTION__,__LINE__,diskFree);
    }

    printf("[%s:%d]sd card diskFree=%lluM\n", __FUNCTION__, __LINE__, diskFree);

    return ret;
}


void sf_sd_exist_reg_cb(SF_CALLBACK_SD_CMD fpCB)
{
	g_fpSd_Exist_CB = fpCB;
}

BOOL sf_in_card_exist(void)
{
    return DrvCARD_DetStrgCard();
    /*
    if(g_fpSd_Exist_CB)
    {
       return g_fpSd_Exist_CB();
    }
    else
    {
        return FALSE;
    }*/

}

void SF_RtosStrgInit(void)
{
    for(int i = 0; i < MMC_DEV_MAX_NUM; i++)
    {
        sf_rtos_mmc_dev[i] = (SF_RTOS_ST_MMC_DEV *)malloc(sizeof(SF_RTOS_ST_MMC_DEV));
        if(sf_rtos_mmc_dev[i] == NULL) {
            // 处理内存分配失败的情况
        }
        sf_rtos_mmc_dev[i]->dcf_handle        = -1;
		sf_rtos_mmc_dev[i]->dev_type          = MMC_DEV_NO;
        //sf_rtos_mmc_dev[i]->node              = MMC_DEV_NODE_STATE_NO;
        sf_rtos_mmc_dev[i]->moumted_state     = MMC_DEV_MOUNT_STATE_NO;
        sf_rtos_mmc_dev[i]->space_state       = MMC_DEV_SPACE_STATE_NO;
        //sf_rtos_mmc_dev[i]->loop_state        = MMC_DEV_LOOP_STATE_NO;
    }
	DBG_WRN("SF_RtosStrgInit!\n");
}

void SF_RtosStrgUnInit(void)
{
    for(int i = 0; i < MMC_DEV_MAX_NUM; i++)
    {
        if(sf_rtos_mmc_dev[i] != NULL) {
            free(sf_rtos_mmc_dev[i]);
            sf_rtos_mmc_dev[i] = NULL;
        }
    }
	DBG_WRN("SF_RtosStrgUnInit!\n");
}

static UINT32 sf_rtos_mmc_dev_space_check_full(MMC_DEV_TYPE mmc_dev)
{
	UINT64 diskFree = 0;
    UINT32 ret = 0;
        
    //UIMenuStoreInfo *puiPara = sf_ui_para_get();
    if(!sf_in_card_exist())
    {
        return 1;
    }

    /*check disk free size*/
	if(mmc_dev == MMC_DEV_SD)
	{
		diskFree = FileSys_GetDiskInfo(FST_INFO_FREE_SPACE);
	}
	else
	{
		diskFree = FileSys_GetEMMCDiskInfo(FST_INFO_FREE_SPACE);
	}
	
    diskFree = diskFree/1024/1024;
    
    if(diskFree < 30) /* 30MB */
    {
        ret = 1;
        IsCardFull = TRUE;
    }
    else
    {
        ret = 0;
    }
    DBG_WRN("[%d]sd card diskFree=%lluM, ret = %d\n", __LINE__, diskFree, ret);
    return ret;
}

int SF_RtosStrgRegister(int devid, int mounted_state)
{
	if(mounted_state == FST_STA_OK)
	{
		sf_rtos_mmc_dev[devid]->moumted_state = MMC_DEV_MOUNT_STATE_MOUNTED;
	}
	else
	{
		sf_rtos_mmc_dev[devid]->moumted_state = MMC_DEV_MOUNT_STATE_UNMOUNTED;
	}

	UINT32 isfull = sf_rtos_mmc_dev_space_check_full(devid);
	if(isfull == 1)
	{
		sf_rtos_mmc_dev[devid]->space_state = MMC_DEV_SPACE_STATE_NO_ENOUGH;
	}
	else if(isfull == 0)
	{
		sf_rtos_mmc_dev[devid]->space_state = MMC_DEV_SPACE_STATE_ENOUGH;
	}
	DBG_WRN("11devid = %d, state = %d\n", devid, mounted_state);
	return 0;
}

void SF_RtosStrgSetDcfHandle(UINT32 strg_id, UINT32 handle)
{
	sf_rtos_mmc_dev[strg_id]->dcf_handle = handle;
	DBG_WRN("strg_id = %d, handle = %d\n", strg_id, handle);
}


SF_RTOS_ST_MMC_DEV *SF_RtosStrgCheckWorkableDev(void)
{
	MMC_DEV_TYPE workable_dev = MMC_DEV_NO;

	if((sf_rtos_mmc_dev[MMC_DEV_SD]->moumted_state == MMC_DEV_MOUNT_STATE_UNMOUNTED) &&
		(sf_rtos_mmc_dev[MMC_DEV_EMMC]->moumted_state == MMC_DEV_MOUNT_STATE_UNMOUNTED))
	{
		workable_dev = MMC_DEV_NO;
	}
    else if(sf_rtos_mmc_dev[MMC_DEV_SD]->moumted_state == MMC_DEV_MOUNT_STATE_UNMOUNTED)
    {
        if(sf_rtos_mmc_dev[MMC_DEV_EMMC]->space_state == MMC_DEV_SPACE_STATE_ENOUGH)
        {
            workable_dev = MMC_DEV_EMMC;
        }
        else
        {
            //if(sf_rtos_mmc_dev[MMC_DEV_SD]->loop_state == MMC_DEV_LOOP_STATE_ON)
            {
                //workable_dev = MMC_DEV_EMMC;
            }
        }
    }
    else if(sf_rtos_mmc_dev[MMC_DEV_EMMC]->moumted_state == MMC_DEV_MOUNT_STATE_UNMOUNTED)
    {
        if(sf_rtos_mmc_dev[MMC_DEV_SD]->space_state == MMC_DEV_SPACE_STATE_ENOUGH)
        {
            workable_dev = MMC_DEV_SD;
        }
        else
        {
            //if(sf_rtos_mmc_dev[MMC_DEV_SD]->loop_state == MMC_DEV_LOOP_STATE_ON)
            {
                //workable_dev = MMC_DEV_SD;
            }
        }
    }
    else
    {
        if(sf_rtos_mmc_dev[MMC_DEV_EMMC]->space_state == MMC_DEV_SPACE_STATE_ENOUGH &&
           sf_rtos_mmc_dev[MMC_DEV_SD]->space_state == MMC_DEV_SPACE_STATE_ENOUGH)
        {
            workable_dev = MMC_DEV_EMMC;
        }
        else if(sf_rtos_mmc_dev[MMC_DEV_EMMC]->space_state == MMC_DEV_SPACE_STATE_ENOUGH)
        {
            workable_dev = MMC_DEV_EMMC;
        }
        else if(sf_rtos_mmc_dev[MMC_DEV_SD]->space_state == MMC_DEV_SPACE_STATE_ENOUGH)
        {
            workable_dev = MMC_DEV_SD;
        }
        else
        {
            //if(sf_rtos_mmc_dev[MMC_DEV_SD]->loop_state == MMC_DEV_LOOP_STATE_ON)
            {
                //workable_dev = MMC_DEV_EMMC;
            }
        }
    }

	
	DBG_WRN("dev_id = %d!!!\n", workable_dev);
	for(int i = 0; i < 2; i++)
	{
		sf_rtos_mmc_dev[i]->dev_type = workable_dev;
		DBG_WRN("mount:%d, space:%d\n", sf_rtos_mmc_dev[i]->moumted_state, 
				sf_rtos_mmc_dev[i]->space_state);
	}
	if(workable_dev == MMC_DEV_NO)
	{
		return NULL;
	}
	else
	{
		return sf_rtos_mmc_dev[workable_dev];
	}

}