#include "uds_bsw_flash.h"
#include "uds_bsw_flash_if.h"
#include "../app/bl_flash.h"
#include "../cdd/CddSbc/CddSbc_TLE9471.h"


/*==============================================================================
=======               DEFINES & MACROS FOR GENERAL PURPOSE               =======
==============================================================================*/

/*==============================================================================
=======                        CONSTANTS & TYPES                         =======
==============================================================================*/

/*==============================================================================
=======                 VARIABLES & MESSAGES & RESSOURCEN                =======
==============================================================================*/
FlashPageBuffer_t flashPageBuffer;

/*==============================================================================
=======                             METHODS                              =======
==============================================================================*/
static uint8_t Flash_StartFlushStatus(void);
static uint8_t FlashSwitchBuffer(void);

static FlashWritePollingState_t flashPollingStateMachine = FlashWrite_Idle;

extern void FlsPgm_SetProgramAddr(uint32_t addr);

void Bsw_flashPageProgInit(void)
{
    uint16_t  index;
    flashPageBuffer.BufferRecePtr       = 0;
    flashPageBuffer.BufferPageProgPtr   = 0;
    flashPageBuffer.ProgrammingAddress  = 0xFFFFFFFF;

    /* ====buffer 0 initialization============== */
    flashPageBuffer.FlsPageDataBufer[0].State           = CodeFlash_CACHE_IDLE;
    flashPageBuffer.FlsPageDataBufer[0].InbufferIndex   = 0u;
    for (index = 0; index < 512; index++)
    {
        flashPageBuffer.FlsPageDataBufer[0].Data[index] = 0xFF;
    }

    /* ====buffer 1 initialization============== */
    flashPageBuffer.FlsPageDataBufer[1].State           = CodeFlash_CACHE_IDLE;
    flashPageBuffer.FlsPageDataBufer[1].InbufferIndex   = 0u;
    for (index = 0; index < 512; index++)
    {
        flashPageBuffer.FlsPageDataBufer[1].Data[index] = 0xFF;
    }
}

static uint8_t FlashSwitchBuffer(void)
{
    uint8_t  res_value = 0;
    uint16_t sub_index;

    sub_index = flashPageBuffer.BufferRecePtr;

    if (flashPageBuffer.FlsPageDataBufer[((sub_index + 1) % 2)].State == CodeFlash_CACHE_IDLE)
    {
        /* another buffer is empty, switch the received buffer */
        flashPageBuffer.BufferRecePtr = ((sub_index + 1) % 2);
        flashPageBuffer.FlsPageDataBufer[flashPageBuffer.BufferRecePtr].InbufferIndex = 0;
    }
    else
    {
        /* buffer switch error handle */
        res_value = 0xFF;
    }
    return res_value;
}

void FlsPgm_SetProgramAddr(uint32_t addr)
{
    flashPageBuffer.ProgrammingAddress = addr;
}

uint8_t FlsPgm_IntWriteByte(uint32_t Address, uint32_t pktLength, uint8_t * pData, void(*pcallback)(uint8_t))
{
    uint8_t  res_value = 0u;
    uint16_t index;
    uint16_t sub_index;
    uint8_t *SourceDataptr;

    sub_index = flashPageBuffer.BufferRecePtr;

    if (CodeFlash_CACHE_IDLE == flashPageBuffer.FlsPageDataBufer[flashPageBuffer.BufferRecePtr].State)
    {
        flashPageBuffer.FlsPageDataBufer[flashPageBuffer.BufferRecePtr].InbufferIndex = 0;
    }
    else if(CodeFlash_CACHE_DIRTY == flashPageBuffer.FlsPageDataBufer[flashPageBuffer.BufferRecePtr].State)
    {
        /* Do Nothing */
    }
    else
    {
        /* the buffer is waiting for written*/
        res_value = 0xFF;
    }

    if (res_value == 0u)
    {
        SourceDataptr = pData;
        for (index = 0; index < pktLength; index++)
        {

            if (flashPageBuffer.FlsPageDataBufer[flashPageBuffer.BufferRecePtr].InbufferIndex < 2048)
            {
                /* the current buffer is not full */
            }
            else
            {
                /* current buffer is full */
                res_value = FlashSwitchBuffer();
            }

            if(res_value == 0u)
            {
                sub_index = flashPageBuffer.FlsPageDataBufer[flashPageBuffer.BufferRecePtr].InbufferIndex;
                flashPageBuffer.FlsPageDataBufer[flashPageBuffer.BufferRecePtr].Data[sub_index] = SourceDataptr[index];
                flashPageBuffer.FlsPageDataBufer[flashPageBuffer.BufferRecePtr].State           = CodeFlash_CACHE_DIRTY;
                flashPageBuffer.FlsPageDataBufer[flashPageBuffer.BufferRecePtr].InbufferIndex++;
            }
            else
            {
                break;
            }
        }

        if (res_value == 0u)
        {
            flashPageBuffer.FlashPagePragCallback = pcallback;
            res_value = Flash_StartFlushStatus();
        }
        else
        {
        }
    }
    return res_value;
}

FlashWritePollingState_t GetFlashProgState(void)
{
    return flashPollingStateMachine;
}

void FlashPageProgStatePolling(void)
{
    uint8_t* pwriteBuffer;
    uint8_t writeCounter = 0;

    switch (flashPollingStateMachine)
    {
    case FlashWrite_Idle:

        break;

    case FlashWrite_Start:
        flashPageBuffer.BufferPageProgPtr = 0;
        if (flashPageBuffer.FlsPageDataBufer[flashPageBuffer.BufferPageProgPtr].State == CodeFlash_CACHE_WR_PENDING)
        {
            flashPollingStateMachine = FlashWrite_Busy;
        }
        else
        {
            flashPollingStateMachine = FlashWrite_NextBuffer;
        }

        break;

    case FlashWrite_Busy:
        /* the code flash flushing must be blocking mode after careful consideration */
        pwriteBuffer = flashPageBuffer.FlsPageDataBufer[flashPageBuffer.BufferPageProgPtr].Data;
        while (writeCounter < 4)
        {
/*            __disable_irq();*/
           /* NVIC_DisableIRQ(CPUIntIdx2_IRQn);  */             /* disable cantp interrupt */
            SCB_Watch_Dog_Trigger_Function();
            FlashWriteWithPadding(pwriteBuffer,512,flashPageBuffer.ProgrammingAddress);
           /* NVIC_EnableIRQ(CPUIntIdx2_IRQn);*/
/*            __enable_irq();*/

            flashPageBuffer.ProgrammingAddress += 512;
            
            writeCounter++;
            pwriteBuffer += 512;
        }
        flashPollingStateMachine = FlashWrite_ResultCheck;
        break;

    case FlashWrite_ResultCheck:
        flashPageBuffer.FlsPageDataBufer[flashPageBuffer.BufferPageProgPtr].State = CodeFlash_CACHE_IDLE;
        flashPollingStateMachine = FlashWrite_NextBuffer;

        break;

    case FlashWrite_NextBuffer:
        if (flashPageBuffer.BufferPageProgPtr == 0)
        {
            flashPageBuffer.BufferPageProgPtr = 1;
            if (flashPageBuffer.FlsPageDataBufer[flashPageBuffer.BufferPageProgPtr].State == CodeFlash_CACHE_WR_PENDING)
            {
                flashPollingStateMachine = FlashWrite_Busy;
            }
            else
            {
                flashPollingStateMachine = FlashWrite_complete;
            }
        }
        else
        {
            flashPollingStateMachine = FlashWrite_complete;
        }

        break;
    case FlashWrite_complete:
        flashPollingStateMachine = FlashWrite_Idle;
        if (flashPageBuffer.FlashPagePragCallback != NULL)
        {
            flashPageBuffer.FlashPagePragCallback(0);
            flashPageBuffer.FlashPagePragCallback = NULL;
        }
        else
        {
        }
        break;
    default:
        flashPollingStateMachine = FlashWrite_Idle;
        break;
    }

}

static uint8_t Flash_StartFlushStatus(void)
{
    uint8_t res_value = 0u;
    uint8_t index;
    uint8_t noWriting = 0;
    for(index = 0; index < 2 ; index++ )
    {
        if( (flashPageBuffer.FlsPageDataBufer[index].State == CodeFlash_CACHE_DIRTY)&&
                (flashPageBuffer.FlsPageDataBufer[index].InbufferIndex >= 512) )
        {
            flashPageBuffer.FlsPageDataBufer[index].State = CodeFlash_CACHE_WR_PENDING;
            noWriting = 0xFF;
            if(index == flashPageBuffer.BufferRecePtr)
            {
                /* need to switch receive buffer */
                res_value = FlashSwitchBuffer();
            }
            flashPollingStateMachine = FlashWrite_Start;
            break;
        }
    }

    if(noWriting == 0u)
    {
        /* no buffer is full */
        if(flashPageBuffer.FlashPagePragCallback != NULL)
        {
            flashPageBuffer.FlashPagePragCallback(0u);
            flashPageBuffer.FlashPagePragCallback = NULL;
        }
    }
    return res_value;
}


void Flash_LastFlushClear(void(*pcallback)(uint8_t))
{
    uint8_t index;
    for(index = 0; index < 2 ; index++ )
    {
        if(flashPageBuffer.FlsPageDataBufer[index].State == CodeFlash_CACHE_DIRTY)
        {
            flashPageBuffer.FlsPageDataBufer[index].State = CodeFlash_CACHE_WR_PENDING;
        }
    }
    flashPageBuffer.FlashPagePragCallback = pcallback;
    flashPollingStateMachine = FlashWrite_Start;
}