/*
 * MCU_E2Prom.c
 *
 *  Created on: July 22, 2019
 *      Author: shlomo
 */

#include "include.h"
#include <DataDef.h>
#include "MCU_E2Prom.h"
#include "driverlib/eeprom.h"
#include "drivers/I2C_Communication/ADC_MUX/ADC_MUX.h"
#include "Drivers/I2C_Communication/Main_Board_EEPROM/Main_EEPROM.h"
#include "Common/SW_Info/SW_Info.h"

#include <PMR/Stubs/StubMainCardEEpromReadRequest.pb-c.h>
#include <PMR/Stubs/StubMainCardEEpromReadResponse.pb-c.h>
#include <PMR/Stubs/StubMainCardEEpromWriteRequest.pb-c.h>
#include <PMR/Stubs/StubMainCardEEpromWriteResponse.pb-c.h>

#include "PMR/EmbeddedParameters/MainCardStoredData.pb-c.h"
#include "PMR/EmbeddedParameters/MainCardStoredDataResponse.pb-c.h"
#include "PMR/EmbeddedParameters/MainCardStoredDataRequest.pb-c.h"
#include "PMR/EmbeddedParameters/MainCardStoredItem.pb-c.h"
#include "PMR/Printing/BTSRParameters.pb-c.h"

uint32_t E2Prom_Data[MAX_EEPROM_STORAGE] = {0,0,0,0,0,0};
uint32_t MCU_E2PromProgram(int Address,uint32_t Data)
{
    uint32_t Buffer = Data;
    if (Address>=MAX_EEPROM_STORAGE)
    {
        Report("MCU_E2PromProgram Error",__FILE__,__LINE__,Address,RpWarning,Data,0);
        return ERROR;
    }
    if ((Address>=EEPROM_STORAGE_DANCER_0)&&(Address<=EEPROM_STORAGE_DANCER_2))
    {
        Report("~~~~~~Store dancers eeprom ",__FILE__,__LINE__,(int)Address,RpWarning,(int)Data,0);

    }
    Report("MCU_E2PromProgram",__FILE__,__LINE__,Address,RpWarning,Data,0);
#ifdef EVALUATION_BOARD
    return 0;
#else
    return (EEPROMProgram((uint32_t *)&Buffer, Address*4, 4));
#endif
}

uint32_t MCU_E2PromRead(int Address,uint32_t *Data)
{
    if (Address>=MAX_EEPROM_STORAGE)
    {
        Report("MCU_E2PromRead Error",__FILE__,__LINE__,Address,RpWarning,*Data,0);
        //return ERROR;
    }
#ifndef EVALUATION_BOARD
    EEPROMRead((uint32_t *)Data,Address*4, 4);
#endif
    Report("MCU_E2PromRead",__FILE__,__LINE__,Address,RpWarning,*Data,0);

    return OK;

}

uint32_t MCU_E2PromProgramFloat(int Address,float Data)
{
    float Buffer = Data;
    if (Address>=MAX_EEPROM_STORAGE)
    {
        Report("MCU_E2PromProgram Error",__FILE__,__LINE__,Address,RpWarning,Data,0);
        return ERROR;
    }
    if ((Address>=EEPROM_STORAGE_DANCER_0)&&(Address<=EEPROM_STORAGE_DANCER_2))
    {
        Report("~~~~~~Store dancers eeprom ",__FILE__,__LINE__,(int)Address,RpWarning,(int)Data,0);

    }
    Report("MCU_E2PromProgram",__FILE__,__LINE__,Address,RpWarning,(int)Data*1000,0);
#ifdef EVALUATION_BOARD
    return 0;
#else
    return (EEPROMProgram((float *)&Buffer, Address*4, 4));
#endif
}

uint32_t MCU_E2PromReadFloat(int Address,float *Data)
{
    if (Address>=MAX_EEPROM_STORAGE)
    {
        Report("MCU_E2PromRead Error",__FILE__,__LINE__,Address,RpWarning,(int)(*Data)*1000,0);
        //return ERROR;
    }
#ifndef EVALUATION_BOARD
    EEPROMRead((float *)Data,Address*4, 4);
#endif
    Report("MCU_E2PromRead",__FILE__,__LINE__,Address,RpWarning,(int)(*Data)*1000,0);

    return OK;

}

/**************************************************/
uint32_t MCU_E2PromProgramChunk(int Address,uint16_t Length,uint32_t Data)
{
    uint32_t Buffer = Data;
#ifdef EVALUATION_BOARD
    return 0;
#else
    Report("MCU_E2PromProgramChunk",__FILE__,Length,Address,RpWarning,Data,0);
    return (EEPROMProgram((uint32_t *)Buffer, Address, Length));
#endif
}
uint32_t MCU_E2PromReadChunk(int Address,uint16_t Length,uint32_t *Data)
{
#ifndef EVALUATION_BOARD
    EEPROMRead((uint32_t *)Data,Address, Length);
#endif
    Report("MCU_E2PromReadChunk",__FILE__,Length,Address,RpWarning,*Data,0);

    return OK;

}
void MCU_E2PromUpdateResetReason(int i)
{
    uint32_t Head;
    uint32_t RESC = SysCtlResetCauseGet();

#ifndef EVALUATION_BOARD

    EEPROMRead(&Head,EEPROM_RESET_REASON_HEAD_ADDRESS, 4);
    if (Head>=EEPROM_RESET_REASON_MAX_DATA) Head=0;
    Head++;
    RESC+=(i*0x1000);
    EEPROMProgram(&Head, EEPROM_RESET_REASON_HEAD_ADDRESS, 4);
    EEPROMProgram(&RESC, (EEPROM_RESET_REASON_HEAD_ADDRESS+(Head*4)), 4);
#endif
}

/*************************************************/
void MCU_E2PromProgramMidTank(int midtankId,float a,float b)
{
    float A,B;
    int Address = 0;

    Address = EEPROM_STORAGE_MIDTANK_1_A+2*midtankId;
    A = a;
    Report("MCU_E2PromProgramMidTank",__FILE__,midtankId,Address,RpWarning,(int)(a*1000),0);

#ifndef EVALUATION_BOARD
    EEPROMProgram((uint32_t *)&A, Address*4, 4);
#endif

    Address = EEPROM_STORAGE_MIDTANK_1_B+2*midtankId;
    B = b;
    Report("MCU_E2PromProgramMidTank",__FILE__,midtankId,Address,RpWarning,(int)(b*1000),0);

#ifndef EVALUATION_BOARD
    EEPROMProgram((uint32_t *)&B, Address*4, 4);
#endif
}
float MCU_E2PromReadMidtank_A(int MidtankId)
{
    int Address = EEPROM_STORAGE_MIDTANK_1_A+(MidtankId*2);
    float Data;
    if (MidtankId>=NUM_OF_MIDTANKS)
    {
        Report("MCU_E2PromReadMidtank error",__FILE__,__LINE__,Address,RpWarning,(int)MidtankId,0);
        return ERROR;
    }
#ifndef EVALUATION_BOARD
    EEPROMRead((uint32_t *)&Data,Address*4, 4);
#endif
    Report("MCU_E2PromRead",__FILE__,__LINE__,Address,RpWarning,(int)(Data*1000),0);

    return (Data);
}
float MCU_E2PromReadMidtank_B(int MidtankId)
{
    int Address = EEPROM_STORAGE_MIDTANK_1_B+(MidtankId*2);
    float Data;
    if (MidtankId>=NUM_OF_MIDTANKS)
    {
        Report("MCU_E2PromReadMidtank error",__FILE__,__LINE__,Address,RpWarning,(int)MidtankId,0);
        return ERROR;
    }
#ifndef EVALUATION_BOARD
    EEPROMRead((uint32_t *)&Data,Address*4, 4);
#endif
    Report("MCU_E2PromRead",__FILE__,__LINE__,Address,RpWarning,(int)(Data*1000),0);

    return (Data);
}
/*uint32_t MCU_E2PromSerialNumProgram(char *Data)
{
    char * SerialNum = Data;
    int len = strlen(SerialNum);
    if (len > MAX_SERIAL_NUM_LEN)
    {
        Report("MCU_E2PromSerialNumProgram length error",__FILE__,__LINE__,len,RpWarning,(int)0,0);
        return ERROR;
    }
    EEPROMProgram((uint32_t *)SerialNum, EEPROM_STORAGE_SERIAL_NUM*4, MAX_SERIAL_NUM_LEN);


    return OK;
}
uint32_t MCU_E2PromSerialNumRead(char* *Data)
{

    char SerialNum[MAX_SERIAL_NUM_LEN];
    EEPROMRead((uint32_t *)SerialNum,EEPROM_STORAGE_SERIAL_NUM*4, MAX_SERIAL_NUM_LEN);

    int len = strlen(SerialNum);
    strcpy(Data,SerialNum);
    Report("MCU_E2PromSerialNumRead length ",__FILE__,__LINE__,len,RpWarning,(int)0,0);

    return len;

}*/
uint32_t MCU_E2PromEmbeddedVersionProgram(void)
{
    uint16_t size;
    uint32_t Data;
    size= sizeof(TangoVersion_t);
    if (size>4)
    {
        Report("MCU_E2PromEmbeddedVersionProgram length error",__FILE__,__LINE__,size,RpWarning,(int)0,0);
        return ERROR;
    }
    memcpy((uint8_t*)&Data,&_gTangoVersion,size);
#ifndef EVALUATION_BOARD
    EEPROMProgram((uint32_t *)&Data, EEPROM_STORAGE_EMBEDDED_VERSION*4, 4);
#endif
    return OK;
}
uint32_t MCU_E2PromEmbeddedVersionRead()
{
    uint32_t Data;
#ifndef EVALUATION_BOARD
    EEPROMRead((uint32_t *)&Data,EEPROM_STORAGE_EMBEDDED_VERSION*4, 4);
#endif

    Report("MCU_E2PromEmbeddedVersionRead length ",__FILE__,__LINE__,EEPROM_STORAGE_EMBEDDED_VERSION*4,RpWarning,(int)(Data),0);

    return Data;
}

//Each word may not be subject to more than a specific number of programming cycles before an
//erase cycle is required. In other words, for any given word, FlashProgram can only be called
//twice before FlashErase is called.
void MCU_E2PromInit(void)
{
#ifndef EVALUATION_BOARD
    EEPROMInit();
#endif
}
void MainCardStoredItemRequestFunc(MessageContainer* requestContainer)
{
    uint32_t status = PASSED,i;
    MessageContainer responseContainer;

    MainCardStoredItem StoredData[MAX_EEPROM_STORAGE];
    MainCardStoredDataRequest* request = main_card_stored_data_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    MainCardStoredData MainCardStoredDataInstance = MAIN_CARD_STORED_DATA__INIT;

    Report("MainCardStoredItemRequestFunc",__FILE__,__LINE__,1,RpWarning,(int)request->burnrequest,0);
    MainCardStoredDataResponse response =   MAIN_CARD_STORED_DATA_RESPONSE__INIT;

    if (request->burnrequest == true)
    {
        if (strcmp(request->maincardstoreddata->maincards_n,Serial)==0)
        {
            for (i = 0;i<request->maincardstoreddata->n_storeditem;i++)
            {
                if ((request->maincardstoreddata->storeditem[i]->has_data)&&(request->maincardstoreddata->storeditem[i]->address == i))
                {
                    MCU_E2PromProgram(i,&request->maincardstoreddata->storeditem[i]->data);
                }
            }
        }
        else
        {
            status = ERROR_CODE__INVALID_PARAMETER;
        }
    }
    else
    {
        response.maincardstoreddata = &MainCardStoredDataInstance;
        MainCardStoredDataInstance.maincards_n = &Serial[0];
        MainCardStoredDataInstance.n_storeditem = MAX_EEPROM_STORAGE;
        MainCardStoredDataInstance.storeditem = my_malloc(MAX_EEPROM_STORAGE*sizeof(MainCardStoredItem *));
        for (i = 0;i<MAX_EEPROM_STORAGE;i++)
        {
            main_card_stored_item__init(&StoredData[i]);
            StoredData[i].has_address = true;
            StoredData[i].has_data = true;
            StoredData[i].address = i;
            MCU_E2PromRead(i,&StoredData[i].data);
            MainCardStoredDataInstance.storeditem[i] = &StoredData[i];
        }
    }

    responseContainer = createContainer(MESSAGE_TYPE__MainCardStoredDataResponse, requestContainer->token, true, &response, &main_card_stored_data_response__pack, &main_card_stored_data_response__get_packed_size);

    if (status)
    {
        responseContainer.has_error = true;
        responseContainer.error = 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);

    main_card_stored_data_request__free_unpacked(request,NULL);

}
void MainCardEEpromReadRequestFunc(MessageContainer* requestContainer)
{

    uint32_t status = PASSED;
    MessageContainer responseContainer;

    StubMainCardEEpromReadRequest* request = stub_main_card_eeprom_read_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    StubMainCardEEpromReadResponse response =   STUB_MAIN_CARD_EEPROM_READ_RESPONSE__INIT;

    if (request->has_address == true)
    {
        response.has_address = true;
        response.address = request->address;

        response.has_data = true;
        status = MCU_E2PromRead(request->address,&response.data);

    }
    else
    {
        status = ERROR_CODE__INVALID_PARAMETER;
    }
    responseContainer = createContainer(MESSAGE_TYPE__StubMainCardEEpromReadResponse, requestContainer->token, true, &response, &stub_main_card_eeprom_read_response__pack, &stub_main_card_eeprom_read_response__get_packed_size);

    if (status)
    {
        responseContainer.has_error = true;
        responseContainer.error = 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_main_card_eeprom_read_request__free_unpacked(request,NULL);

}


void MainCardEEpromWriteRequestFunc(MessageContainer* requestContainer)
{

    uint32_t status = PASSED;
    MessageContainer responseContainer;

    StubMainCardEEpromWriteRequest* request = stub_main_card_eeprom_write_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    StubMainCardEEpromWriteResponse response =   STUB_MAIN_CARD_EEPROM_WRITE_RESPONSE__INIT;

    if (request->has_address == true)
    {
        status = MCU_E2PromProgram(request->address,request->data);
    }
    else
    {
        status = ERROR_CODE__INVALID_PARAMETER;
    }
    response.has_address = true;
    response.address = request->address;
    response.has_data = true;
    MCU_E2PromRead(request->address,&response.data);

    responseContainer = createContainer(MESSAGE_TYPE__StubMainCardEEpromWriteResponse, requestContainer->token, true, &response, &stub_main_card_eeprom_write_response__pack, &stub_main_card_eeprom_write_response__get_packed_size);

    if (status)
    {
        responseContainer.has_error = true;
        responseContainer.error = 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_main_card_eeprom_write_request__free_unpacked(request,NULL);

}

uint32_t BtsrSaveParamsToEeprom(void *Data)
{
    BTSRParameters* BtsrPrameters = Data;
    BTSRParameters ExistingBtsrPrameters ;
    uint32_t status = 0;
    float data;

    BtsrReadParamsFromEeprom(&ExistingBtsrPrameters);
    if (memcmp(BtsrPrameters,&ExistingBtsrPrameters,sizeof(ExistingBtsrPrameters)))
    {
        data = BtsrPrameters->feedingtension;
        status |= MCU_E2PromProgramFloat(EEPROM_BTSR_FEEDING_TENSION, data);
        status |= MCU_E2PromProgram(EEPROM_BTSR_TYPE, BtsrPrameters->btsryarntype);
        status |= MCU_E2PromProgram(EEPROM_BTSR_APPLICATION, BtsrPrameters->btsrapplicationtype);
        data = BtsrPrameters->threadlengthfactor;
        status |= MCU_E2PromProgramFloat(EEPROM_BTSR_LENGTH_OFFSET, data);
        data = BtsrPrameters->tensionerror;
        status |= MCU_E2PromProgramFloat(EEPROM_BTSR_TENSION_ERROR, data);
        data = BtsrPrameters->spooltension;
        status |= MCU_E2PromProgramFloat(EEPROM_BTSR_SPOOL_TENSION, data);
        data = BtsrPrameters->exittension;
        status |= MCU_E2PromProgramFloat(EEPROM_BTSR_EXIT_TENSION, data);
    }
    return status;
}

uint32_t BtsrReadParamsFromEeprom(void *Data)
{
    BTSRParameters* BtsrPrameters = Data;
    uint32_t status = 0;
    float data;
    uint32_t value;

    status |= MCU_E2PromReadFloat(EEPROM_BTSR_FEEDING_TENSION, &data);
    BtsrPrameters->feedingtension = data;
    status |= MCU_E2PromRead(EEPROM_BTSR_TYPE, &value);
    BtsrPrameters->btsryarntype = value;
    status |= MCU_E2PromRead(EEPROM_BTSR_APPLICATION, &value);
    BtsrPrameters->btsrapplicationtype = value;
    status |= MCU_E2PromReadFloat(EEPROM_BTSR_LENGTH_OFFSET, &data);
    BtsrPrameters->threadlengthfactor = data;
    status |= MCU_E2PromReadFloat(EEPROM_BTSR_TENSION_ERROR, &data);
    BtsrPrameters->tensionerror = data;
    status |= MCU_E2PromReadFloat(EEPROM_BTSR_SPOOL_TENSION, &data);
    BtsrPrameters->spooltension = data;
    status |= MCU_E2PromReadFloat(EEPROM_BTSR_EXIT_TENSION, &data);
    BtsrPrameters->exittension = data;
    Report("BtsrReadParamsFromEeprom",__FILE__,(int)(BtsrPrameters->feedingtension*1000),(int)(BtsrPrameters->tensionerror*1000),RpWarning,(int)(BtsrPrameters->exittension*1000), 0);
    Report("BtsrReadParamsFromEeprom",__FILE__,BtsrPrameters->btsrapplicationtype,BtsrPrameters->btsryarntype,RpWarning,(int)(BtsrPrameters->threadlengthfactor*1000), 0);
    return status;
}