#include <Container.h>
#include <PMR/Common/MessageContainer.pb-c.h>
#include <PMR/Stubs/StubExtFlashReadRequest.pb-c.h>
#include <PMR/Stubs/StubExtFlashReadResponse.pb-c.h>
#include <PMR/Stubs/StubExtFlashWriteRequest.pb-c.h>
#include <PMR/Stubs/StubExtFlashWriteResponse.pb-c.h>
#include <PMR/Stubs/StubExtFlashReadWordsRequest.pb-c.h>
#include <PMR/Stubs/StubExtFlashReadWordsResponse.pb-c.h>
#include <PMR/Stubs/StubExtFlashWriteWordsRequest.pb-c.h>
#include <PMR/Stubs/StubExtFlashWriteWordsResponse.pb-c.h>
#include <drivers/Flash_Memory/Flash_Memory.h>
#include <DataDef.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "inc/hw_uart.h"
#include "driverlib/gpio.h"

#include "Drivers/USB_Communication/USBCDCD.h"



#include "Stub_Status.h"


#define Max_words 5


void Stub_ExtFlashWriteRequest(MessageContainer* requestContainer)
{

    uint32_t WriteBuf[5];
    uint32_t status = PASSED;

    MessageContainer responseContainer;

    StubExtFlashWriteRequest* request = stub_ext_flash_write_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);


    WriteBuf[0] = request->wordtowrite1;
    WriteBuf[1] = request->wordtowrite2;
    WriteBuf[2] = request->wordtowrite3;
    WriteBuf[3] = request->wordtowrite4;
    WriteBuf[4] = request->wordtowrite5;
    

    Ext_Flash_Operation(0X00,TX, Max_words, WriteBuf, NULL );

    StubExtFlashWriteResponse response =   STUB_EXT_FLASH_WRITE_RESPONSE__INIT;

    status_response(status,&response.status, &response.statusword ,&response.has_statusword);

    responseContainer = createContainer(MESSAGE_TYPE__StubExtFlashWriteResponse, requestContainer->token, true, &response, &stub_ext_flash_write_response__pack, &stub_ext_flash_write_response__get_packed_size);


    Write_status_response(status);

    //free(request);
    //-------------------------------------------------------------------------------------------
    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    free(responseContainer.data.data);
    SendChars((char*)container_buffer, container_size);
    //free(container_buffer);
    //free(requestContainer);
    stub_ext_flash_write_request__free_unpacked(request,NULL);

}

void Stub_ExtFlashReadRequest(MessageContainer* requestContainer)
{

    uint32_t status = PASSED;
    MessageContainer responseContainer;

    StubExtFlashReadRequest* request = stub_ext_flash_read_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    uint32_t No_Words;
    uint32_t ReadBuf[Max_words];

    if(request->number_of_words>Max_words)
    {
        No_Words = Max_words;
    }
    else
    {
        No_Words = request->number_of_words;
    }

    Ext_Flash_Operation(0X00,RX, No_Words, NULL, ReadBuf );


    StubExtFlashReadResponse response =   STUB_EXT_FLASH_READ_RESPONSE__INIT;

    status_response(status,&response.status, &response.statusword ,&response.has_statusword);

    response.has_readword_5 = false;
    response.has_readword_4 = false;
    response.has_readword_3 = false;
    response.has_readword_2 = false;
    response.has_readword_1 = false;

    switch(No_Words)
    {
        case 5:
            response.readword_5 = ReadBuf[4];
            response.has_readword_5 = true;
        case 4:
            response.readword_4 = ReadBuf[3];
            response.has_readword_4 = true;
        case 3:
            response.readword_3 = ReadBuf[2];
            response.has_readword_3 = true;
        case 2:
            response.readword_2 = ReadBuf[1];
            response.has_readword_2 = true;
        case 1:
            response.readword_1 = ReadBuf[0];
            response.has_readword_1 = true;
            break;
        default:
            break;
    }

    responseContainer = createContainer(MESSAGE_TYPE__StubExtFlashReadResponse, requestContainer->token, true, &response, &stub_ext_flash_read_response__pack, &stub_ext_flash_read_response__get_packed_size);
    //clear();
    //free(request);
    //-------------------------------------------------------------------------------------------
    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    free(responseContainer.data.data);
    SendChars((char*)container_buffer, container_size);
    //free(container_buffer);
    //free(requestContainer);
    stub_ext_flash_read_request__free_unpacked(request,NULL);

}
//-------------------------------------------------------------------------------------
/*
#define MaxFlashWords 1024 //1K
#define MaxFlashBytes MaxFlashWords*4 //4K Byte

typedef union
{
    uint32_t DWords[MaxFlashWords];
    uint8_t Bytes[MaxFlashBytes];
}Flash_Union;

Flash_Union Flash_RW;

uint32_t WriteBuf[MaxFlashBytes];
uint32_t ReadBuf[MaxFlashBytes];

#define MaxBytesForAddress 256 //The addresses to be programmed must not span a 256-byte boundary
*/

/*
//---------------------------------------------------------------------------------------------
void Stub_ExtFlashWriteWordsRequest(MessageContainer* requestContainer)
{

    uint32_t status = PASSED;

    uint32_t i;
    uint32_t No_Words,No_Bytes;

    MessageContainer responseContainer;

    StubExtFlashWriteWordsRequest* request = stub_ext_flash_write_words_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    StubExtFlashWriteWordsResponse response =   STUB_EXT_FLASH_WRITE_WORDS_RESPONSE__INIT;

    response.address = request->address;
    response.has_address = true;

    No_Words = request->n_wordtwrite;
    No_Bytes = request->n_wordtwrite *4;

    memset(&Flash_RW,0,sizeof(Flash_RW));

    for(i = 0; i < No_Words;i++)
    {
        Flash_RW.DWords[i] = request->wordtwrite[i];
    }

    for(i = 0; i < No_Bytes;i++)
    {
        WriteBuf[i] =  Flash_RW.Bytes[i];
    }

    if(No_Bytes >MaxBytesForAddress)
    {
        uint32_t number = No_Bytes / MaxBytesForAddress;
        uint32_t Remainder = No_Bytes % MaxBytesForAddress;

        for(i=0;i<number;i++)
        {
            Ext_Flash_Operation(0X00 + (0X100*i) , TX, MaxBytesForAddress , WriteBuf+ (MaxBytesForAddress*i), NULL );
        }
        if(Remainder)
        {
            Ext_Flash_Operation(0X00 + (0X100*i) , TX, Remainder , WriteBuf+ (MaxBytesForAddress*i), NULL );
        }
    }
    else
    {
        Ext_Flash_Operation(0X00, TX, No_Bytes  , WriteBuf, NULL );
    }

    status_response(status,&response.status, &response.statusword ,&response.has_statusword);

    responseContainer = createContainer(MESSAGE_TYPE__StubExtFlashWriteWordsResponse, requestContainer->token, true, &response, &stub_ext_flash_write_words_response__pack, &stub_ext_flash_write_words_response__get_packed_size);

    writeLine("Sending Response: ");

    Write_status_response(status);

    //-------------------------------------------------------------------------------------------
    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    free(responseContainer.data.data);
    SendChars((char*)container_buffer, container_size);

    stub_ext_flash_write_words_request__free_unpacked(request,NULL);
}

void Stub_ExtFlashReadWordsRequest(MessageContainer* requestContainer)
{
    uint32_t status = PASSED;
    uint32_t i;
    uint32_t No_Words,No_Bytes;

    MessageContainer responseContainer;

    memset(&Flash_RW,0,sizeof(Flash_RW));

    StubExtFlashReadWordsRequest* request = stub_ext_flash_read_words_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    No_Words = request->number_of_words;
    No_Bytes = request->number_of_words *4;

    if(No_Bytes >MaxBytesForAddress)
    {
        uint32_t number = No_Bytes / MaxBytesForAddress;
        uint32_t Remainder = No_Bytes % MaxBytesForAddress;

        for(i=0;i<number;i++)
        {
            Ext_Flash_Operation(0X00 + (0X100*i), RX, MaxBytesForAddress, NULL, ReadBuf + (MaxBytesForAddress*i) );
        }
        if(Remainder)
        {
            Ext_Flash_Operation(0X00 + (0X100*i), RX, Remainder, NULL, ReadBuf + (MaxBytesForAddress*i) );
        }
    }
    else
    {
        Ext_Flash_Operation(0X00, RX, No_Bytes, NULL, ReadBuf );
    }

    for(i = 0; i < No_Bytes;i++)
    {
        Flash_RW.Bytes[i] = ReadBuf[i];
    }

    StubExtFlashReadWordsResponse response =   STUB_EXT_FLASH_READ_WORDS_RESPONSE__INIT;

    response.readbytes = Flash_RW.DWords;
    response.n_readbytes = No_Words;

    status_response(status,&response.status, &response.statusword ,&response.has_statusword);

    responseContainer = createContainer(MESSAGE_TYPE__StubExtFlashReadWordsResponse, requestContainer->token, true, &response, &stub_ext_flash_read_words_response__pack, &stub_ext_flash_read_words_response__get_packed_size);

    //-------------------------------------------------------------------------------------------
    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    free(responseContainer.data.data);
    SendChars((char*)container_buffer, container_size);
    stub_ext_flash_read_words_request__free_unpacked(request,NULL);
}

*/


//---------------------------------------------------------------------------------------------
void Stub_ExtFlashWriteWordsRequest(MessageContainer* requestContainer)
{
/*
    uint32_t status = PASSED;

    MessageContainer responseContainer;

    StubExtFlashWriteWordsRequest* request = stub_ext_flash_write_words_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    StubExtFlashWriteWordsResponse response =   STUB_EXT_FLASH_WRITE_WORDS_RESPONSE__INIT;

    uint32_t Current_Start_address = ExtFlashWriteBuf(request->n_wordtwrite, request->wordtwrite);// alwayes send sddress 0

    response.address = Current_Start_address;
    response.has_address = true;

    status_response(status,&response.status, &response.statusword ,&response.has_statusword);

    responseContainer = createContainer(MESSAGE_TYPE__StubExtFlashWriteWordsResponse, requestContainer->token, true, &response, &stub_ext_flash_write_words_response__pack, &stub_ext_flash_write_words_response__get_packed_size);


    //-------------------------------------------------------------------------------------------
    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    free(responseContainer.data.data);
    SendChars((char*)container_buffer, container_size);

    stub_ext_flash_write_words_request__free_unpacked(request,NULL);
    */
}

void Stub_ExtFlashReadWordsRequest(MessageContainer* requestContainer)
{
    //uint32_t status = PASSED;

    /*MessageContainer responseContainer;

    StubExtFlashReadWordsRequest* request = stub_ext_flash_read_words_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    StubExtFlashReadWordsResponse response =   STUB_EXT_FLASH_READ_WORDS_RESPONSE__INIT;
    response.readbytes =  ExtFlashReadBuf(request->address,request->number_of_words);
    response.n_readbytes = request->number_of_words;

    response.address = request->address;
    response.has_address = true;

    status_response(status,&response.status, &response.statusword ,&response.has_statusword);

    responseContainer = createContainer(MESSAGE_TYPE__StubExtFlashReadWordsResponse, requestContainer->token, true, &response, &stub_ext_flash_read_words_response__pack, &stub_ext_flash_read_words_response__get_packed_size);

    //-------------------------------------------------------------------------------------------
    uint8_t* container_buffer = malloc(message_container__get_packed_size(&responseContainer));
    size_t container_size = message_container__pack(&responseContainer, container_buffer);
    free(responseContainer.data.data);
    SendChars((char*)container_buffer, container_size);
    stub_ext_flash_read_words_request__free_unpacked(request,NULL);
    */
}