#include "uds_bsw_flash.h"
#include "../cantp/CanTp.h"
#include "uds_fbl_mgr.h"
#include "uds_vmem.h"
MEM_MIDD_ST memCfgTable[] = MEM_CFG_TABLE;

#define MEM_START_RCRRP
#define MEM_STOP_RCRRP      (rcrrp = false) 
#define EME_GET_RCRRP_FLAG  (rcrrp)
extern void FlsPgm_SetProgramAddr(uint32_t addr);

bool rcrrp = false;
uint8_t uds_u8FLUFBLFlashSession = 0x00;

bool MEM_AllotCheck(void)
{
    return true;
}

MEM_TYPE MEM_GetType(uint32_t addr_u32, uint32_t lenght_u32)
{
    
    MEM_TYPE typeIndex_e = MEM_FBL;
    MEM_TYPE recType_e   = MEM_ERROR;
    const MEM_MIDD_ST* memStruct_p = NULL;
    for(typeIndex_e=MEM_FBL;typeIndex_e<MEM_ERROR;typeIndex_e++)
    {   
        memStruct_p = &memCfgTable[typeIndex_e];
        if( (addr_u32>=memStruct_p->startAddr_u32)  &&
            (addr_u32+lenght_u32-1<=memStruct_p->endAddr_u32))/* 地址和长度在设置区间 */
        {
            recType_e = (MEM_TYPE)memStruct_p->type_e;  /* 设置返回值 */
            break;
        }
    }
    return recType_e;
}

bool MEM_AddrVerify(uint32_t addr_u32, uint32_t lenght_u32)
{
    
    MEM_TYPE typeIndex_e = MEM_FBL;
    MEM_TYPE recType_e   = MEM_ERROR;
    bool rec = true;
    const MEM_MIDD_ST* memStruct_p = NULL;
    for(typeIndex_e=MEM_FBL;typeIndex_e<MEM_ERROR;typeIndex_e++)
    {   
        memStruct_p = &memCfgTable[typeIndex_e];
        if( (addr_u32>=memStruct_p->startAddr_u32)  &&
            (addr_u32+lenght_u32-1<=memStruct_p->endAddr_u32))/* 地址和长度在设置区间 */
        {
            recType_e = (MEM_TYPE)memStruct_p->type_e;  /* 设置返回值 */
            break;
        }
    }
    if(recType_e==MEM_ERROR)
    {
        rec = false;
    }
    return rec;
}

MEM_NRC MEM_Erase(MEMADDR_T addr_u32, MEMLEN_T lenght_u32)
{
    MEM_NRC nrc = MEM_OK;
    MEM_TYPE typeIndex_e = MEM_GetType(addr_u32, lenght_u32);

    if((addr_u32 == FLU_FBL_ADDR_START_OnApp)&&(lenght_u32 == MEM_FBL_LEN))
    {
         /*Erase the whole APP area which include APP valid flag*/
         lenght_u32 = MEM_COD_APP_LEN;
         /*Mark that current flash partition is FLU_FBL partition*/
         uds_u8FLUFBLFlashSession = 0x01;
    }
    
    /* Check address validatly */
    if (MEM_ERROR != typeIndex_e)
    {
        /* Check erase or not */
        if (true == memCfgTable[typeIndex_e].writeMustErasen)
        {
            /* excute function pointer checked */
            if (NULL != memCfgTable[typeIndex_e].erase)
            {
                /* Excute Erase */
                nrc = memCfgTable[typeIndex_e].erase(addr_u32, lenght_u32);
            }
            else
            {
                nrc = MEM_ERASE_FAIL;
            }

            if((nrc == MEM_OK)|| (nrc == MEM_RCRRP))
            {
                memCfgTable[typeIndex_e].memIsErasen = true;
            }
            else
            {
                /* Do Nothing */
            }
        }
        else
        {
            /* Do nothing */
        }
    }
    else
    {
        /* 地址内存不存在 */
        nrc = 0x31;
    }

    return nrc;
}

MEM_NRC MEM_Request(MEMADDR_T addr_t,   MEMLEN_T len_t)
{
    MEM_NRC nrc = MEM_OK;
    MEM_TYPE typeIndex_e = MEM_GetType(addr_t, len_t);

    if ((memCfgTable[typeIndex_e].writeMustErasen == true) &&
        (memCfgTable[typeIndex_e].memIsErasen == false))
    {
        nrc = MEM_BSE;  /* 需要擦除但是没有擦除 */
    }
    else if ((typeIndex_e != MEM_ERROR) && (memCfgTable[typeIndex_e].request != NULL))
    {
        nrc = memCfgTable[typeIndex_e].request(addr_t,len_t);
    }
    else if (memCfgTable[typeIndex_e].request == NULL)
    {
        ;
    }
    else
    {
        nrc = MEM_PROGRAM_FAIL;
    }

    return nrc;
}


MEM_NRC MEM_Program(    MEMADDR_T addr_t, 
                        MEMDATA_T* data_t, 
                        MEMLEN_T len_t )
{   
    MEM_NRC nrc = MEM_OK;
    MEM_TYPE typeIndex_e = MEM_GetType(addr_t, len_t);

    if((uds_u8FLUFBLFlashSession != 0x01)&&(addr_t<=0x1FFFFF)&&(addr_t>=0x40000))
    {
        /*Current program partition is APP partition*/
        typeIndex_e = MEM_CAL_APP;
    }

    if((memCfgTable[typeIndex_e].writeMustErasen == true) &&
       (memCfgTable[typeIndex_e].memIsErasen == false))
    {
        nrc = MEM_BSE;  /* 需要擦除但是没有擦除 */
    }   
    else if( (typeIndex_e!=MEM_ERROR) && (memCfgTable[typeIndex_e].program!=NULL) )
    {
        nrc= memCfgTable[typeIndex_e].program(addr_t, data_t, len_t);
    }
    else
    {
        nrc = MEM_PROGRAM_FAIL;
    }

    return nrc;
}


MEM_NRC MEM_FlashDriverProgram( MEMADDR_T addr_t, 
                            MEMDATA_T* data_t, 
                            MEMLEN_T len_t)
{   
    uint32_t index = 0;
    uint32_t add = addr_t;

    uint8_t* flash_driver  = (uint8_t*)add;
    for(index=0;index<len_t;index++)
    {
        *flash_driver++ = *data_t++;
    }
    return MEM_OK;
}

MEM_NRC MEM_FlashCopyAndPaste( MEMADDR_T copy_addr_t, 
                            MEMADDR_T paste_addr_t, 
                            MEMLEN_T len_t)
{   
    uint32_t index = 0;
    uint32_t copyAddr = copy_addr_t;
    uint8_t* flash_copy  = (uint8_t*)copyAddr;
    uint32_t pasteAddr = paste_addr_t;
    uint8_t* flash_patse  = (uint8_t*)pasteAddr;
    for(index=0;index<len_t;index++)
    {
        *flash_patse++ = *flash_copy++;
    }
    return MEM_OK;
}

/****************************************************************************/
/****************************************************************************/
void MEM_EraseCompleteCallBack(uint8_t ret)
{
    uint8_t transdata[5];
    transdata[0] = 0x71;
    transdata[1] = 0x01;
    transdata[2] = 0xFF;
    transdata[3] = 0x00;
    transdata[4] = 0x00;

    network_send_udsmsg(transdata,5);
    udsFbl_StopTimer(TIMER_UDS_ERASE);
    udsFbl_StartTimer(TIMER_UDS_SESSION);
}

MEM_NRC MEM_CodeflashErase(MEMADDR_T addr_t, MEMLEN_T len_t)
{  
    uint32_t add = addr_t;
    FlsPgm_DiagMemoryErase(add, len_t,&MEM_EraseCompleteCallBack);
    return MEM_RCRRP;
}
MEM_NRC MEM_CodeflashRequest(MEMADDR_T addr_t, MEMLEN_T len_t)
{
    FlsPgm_DiagRequestDownload(addr_t, len_t);
    return MEM_OK;
}

void MEM_ProgramCompleteCallBack(uint8_t ret)
{
    uint8_t block;

    block = udsFbl_Get_Download_Block_Cnt();
    if(block == 0)
    {
        block = (uint8_t)0xFF;
    }
    else
    {
        block = block-(uint8_t)1;
    }

    uint8_t transdata[2];
    transdata[0] = 0x76;
    transdata[1] = block;

    network_send_udsmsg(transdata,2);
    udsFbl_StopTimer(TIMER_UDS_PROGRAM);
    udsFbl_StartTimer(TIMER_UDS_SESSION);

}

MEM_NRC MEM_CodeflashProgram(   MEMADDR_T addr_t, 
                            MEMDATA_T* data_t, 
                            MEMLEN_T len_t)
{   
    FlsPgm_SetProgramAddr(addr_t);
    FlsPgm_DiagTransferData(len_t, data_t, &MEM_ProgramCompleteCallBack);
    return MEM_RCRRP;
}

MEM_NRC MEM_EepromErase(MEMADDR_T addr_t, MEMLEN_T len_t)
{
    return MEM_OK;
}

MEM_NRC MEM_EepromProgram(  MEMADDR_T addr_t, 
                        MEMDATA_T* data_t, 
                        MEMLEN_T len_t)
{
    return MEM_OK;
}