#include "uds_serviceapi.h"
#include "../app/bl_flash.h"

/*check dataflash sector result status*/
typedef enum
{
    DATAFLASH_SUCCUSS,         /*Operation dataflash succuss */
    DATAFLASH_PARAMETER_ERR,   /*Input parameter error */
    DATAFLASH_ERASE_FAIL,      /*dataflash erase error */
    DATAFLASH_READ_FAIL,       /*dataflash read  error */
    DATAFLASH_VERIFY_FAIL,     /*dataflash verify error */
    DATAFLASH_WRITE_FAIL,      /*dataflash write error  */
    DATAFLASH_INITIAL_FAIL,    /*dataflash inital error  */
}dataflash_status_t;

/*Use storage  current did  server data  and write counter  and  current position */
typedef struct
{
    uint32_t   u32_counter ;       /*   write  counter  the range is [0-254]*/
    uint8_t   data[MAX_DATA_LEN];  /*   did data  buffer*/
    uint8_t   u8_position;         /*   current  sectors  position*/
} dataflash_multregionType_t;

typedef struct
{
    uint32_t sectorstartAddr;/* dataflash sectors  start  address*/
    uint8_t  sector_offset;  /* dataflash sectors  offset*/
    uint8_t  data_len;       /* data  length*/
    uint8_t  *data;          /* data  poiner*/
    uint8_t  *RAMdata;       /* data  RAM poiner*/
}dataflash_config;

#define DFLASHBACKUP_VALID  0x40
/*dataflashmultregion use storage dataflash didserver temp data*/
static dataflash_multregionType_t dataflashmultregion[DID_SUPPORT_MAX];

/*DID_PROGRAM_COUNT*/
#define  PROGRAM_COUNT_SIZE       8
uint8_t  DEFAULT_PROGRAM_COUNT_DATA[PROGRAM_COUNT_SIZE] = 
{
    0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0xFF
};


/*  DID_BOOTLOADER_VERSION  */
#define  BOOT_VERSION_SIZE       8
uint8_t  DEFAULT_BOOT_VERSION_DATA[BOOT_VERSION_SIZE] = 
{
    0x22, 0x22, 0x22, 0x22, 0xFF, 0xFF, 0xFF, 0xFF
};

/*  DID_FINGERPRINTF  */
#define  FINGERPRINTF_SIZE       12
uint8_t  DAFAULT_FINGERPRINTF_DATA[FINGERPRINTF_SIZE] = 
{
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};

/*  DID_FAA_27_FAIL_FLAG  */
#define  FAA_27_FAIL_FLAG_SIZE    4
uint8_t DAFAULT_FAA_27_FAIL_FLAG_DATA[FAA_27_FAIL_FLAG_SIZE] =
{
    0x00, 0x00, 0x00, 0x00
};

DFlash_RAMBuf_t DFlashRAMBuf = {0};

/*  All DID server  config table  init  default  status */
static const dataflash_config dataflash_server_cfg[DID_SUPPORT_MAX] =
{
    { BOOTLOADER_VERSION_ADDRESS, 0x00, BOOT_VERSION_SIZE,     DEFAULT_BOOT_VERSION_DATA,     DFlashRAMBuf.FBLVersionRAM},      /*DID_BOOTLOADER_VERSION */
    { PROGRAM_COUNT_ADDRESS,      0x10, PROGRAM_COUNT_SIZE,    DEFAULT_PROGRAM_COUNT_DATA,    DFlashRAMBuf.ProgramCntRAM},      /*DID_PROGRAM_COUNT */
    { FINGERPRINTF_ADDRESS,       0x20, FINGERPRINTF_SIZE,     DAFAULT_FINGERPRINTF_DATA,     DFlashRAMBuf.FingerPrintRAM},     /*DID_FINGERPRINTF  */
    { FAA_27_FAIL_FLAG_ADDRESS,   0x30, FAA_27_FAIL_FLAG_SIZE, DAFAULT_FAA_27_FAIL_FLAG_DATA, DFlashRAMBuf.FAA_27_FailFlagRAM}, /*DID_FAA_27_FAIL_FLAG */
};

/*******************************************************************************
* Function Dataflash_Data_Common_Init
****************************************************************************//**
*
* This function will write  8bit default data to address in data flash or read Physical sector  data  copy to  dataflashmultregion data  buffer
*
* \param did  server did  written into

* \return Returns the result (see \ref dataflash_status_t).

*******************************************************************************/
static uint8_t Dataflash_Data_Common_Init(uint8_t did)
{
    return 0;
    /*Currently nothing to do*/
}

uint8_t Dataflash_Common_WriteToRAM(uint8_t did,uint8_t *data)
{
    uint8_t  u8Index;
    for (u8Index = 0; u8Index < dataflash_server_cfg[did].data_len; u8Index++)
    {
        dataflash_server_cfg[did].RAMdata[u8Index] = data[u8Index];
    }
    return 0;
}

/*******************************************************************************
* Function Dataflash_Common_Write
****************************************************************************//**
*
* This function will program 8bit data pointer to address in data flash  user can  write data via did  server
*
* \param did  server did  written into

* \param data pointer to data to be written from
*
* \return Returns the result (see \ref dataflash_status_t).
*******************************************************************************/

uint8_t Dataflash_Common_Write(uint8_t did,bool multi_did)
{
    uint8_t  u8DataFlashBackUp[DFLASHBACKUP_VALID];
    uint8_t  u8Index;
    uint8_t  u8Ret = 0;
    uint8_t  u8Did;
    uint32_t u32Index;
    BlInterruptsDisable();
    /* read data into the RAM buffer from the Data Flash--maybe only need read the valid data area??? */
    for (u32Index = 0; u32Index < DFLASHBACKUP_VALID; u32Index += 1)
    {
        u8DataFlashBackUp[u32Index] = *((uint32_t *)(dataflash_server_cfg[0].sectorstartAddr + u32Index));
    } 
    BlInterruptsEnable();
    /*When finish finger print related Data Flash reading, 
      Erase the whole sector related to finger print---take about 2.2 ms*/
    if(FlashEraseSector(dataflash_server_cfg[did].sectorstartAddr) != SUCC)
    {
        /*Data Flash Erase Failed*/
        u8Ret = 0x01;
    }
    /*Update did related info to temporary RAM*/
    if(multi_did != TRUE)
    {
        /*Single DID Data Flash update*/
       for (u8Index = 0; u8Index < dataflash_server_cfg[did].data_len; u8Index++)
        {
           u8DataFlashBackUp[dataflash_server_cfg[did].sector_offset + u8Index] = dataflash_server_cfg[did].RAMdata[u8Index];
        }
    }
    else
    {
        /*Multiple DID Data Flash update*/
        for (u8Did = 0; u8Did < DID_SUPPORT_MAX; u8Did++)
        {
            for (u8Index = 0; u8Index < dataflash_server_cfg[u8Did].data_len; u8Index++)
            {
               u8DataFlashBackUp[dataflash_server_cfg[u8Did].sector_offset + u8Index] = dataflash_server_cfg[u8Did].RAMdata[u8Index];
            }
        }
    }
    
    /*No need to Write the whole sectors data back, only write back the valid data area*/
    if(FlashWriteWithPadding((uint8_t *)u8DataFlashBackUp, dataflash_server_cfg[DID_SUPPORT_MAX-1].sector_offset + 0x10,dataflash_server_cfg[did].sectorstartAddr) != SUCC)
    {
        /*Data Flash Write Failed*/
        u8Ret = 0x01;
    }
    
    return u8Ret;
    /*Currently nothing to do*/
}

/*******************************************************************************
* Function Dataflash_Common_Read
****************************************************************************//**
*
* This function will program 8bit data pointer to address in data flash  user can  read data via did  server
*
* \param did  server did  written into

* \param data pointer to data to be written from
*
* \return Returns the result (see \ref dataflash_status_t).

*******************************************************************************/
uint8_t Dataflash_Common_Read(uint8_t did ,uint8_t *data)
{
    uint8_t  u8Index;
    if(did == DID_SUPPORT_MAX)
    {
        /*Currently nothing to do*/
    }
    else
    {
       for (u8Index = 0; u8Index < dataflash_server_cfg[did].data_len; u8Index++)
       {
           data[u8Index] = *((uint32_t *)(dataflash_server_cfg[did].sectorstartAddr + dataflash_server_cfg[did].sector_offset + u8Index));
       }
    }
    return 0;
}

/*******************************************************************************
* Function Dataflash_Data_Init
****************************************************************************//**
* This function will init  dataflash  sectors  
*
* \return Returns the result (see \ref dataflash_status_t).
*******************************************************************************/
uint8_t Dataflash_Data_Init(void)
{
    uint8_t status;
    uint8_t result;
    result = DATAFLASH_SUCCUSS;
    for (uint8_t i = 0; i < DID_SUPPORT_MAX; i++)
    {
         status = Dataflash_Data_Common_Init(i);
         if(status!=0)
         {
            result = DATAFLASH_INITIAL_FAIL;
         }
    }  
    return result;
}