#include <Container.h>
#include <DataDef.h>
#include <PMR/Common/MessageContainer.pb-c.h>
#include <PMR/Stubs/StubI2CRequest.pb-c.h>
#include <PMR/Stubs/StubI2CResponse.pb-c.h>

#include <PMR/Stubs/StubI2CWriteBytesRequest.pb-c.h>
#include <PMR/Stubs/StubI2CWriteBytesResponse.pb-c.h>

#include <PMR/Stubs/StubI2CReadBytesRequest.pb-c.h>
#include <PMR/Stubs/StubI2CReadBytesResponse.pb-c.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"
#include "drivers/I2C_Communication/I2C.h"


#include "Drivers/Uart_Comm/BTSR/BTSR.h"

static uint8_t CODE_STRING;//BTSR ID needed to check the checksum, in the response for FUNCTION_STRING = 0x33/0x1C
static uint8_t Function_Code;//needed to check the checksum, in the response for FUNCTION_STRING = 0x33/0x1C

void Stub_I2CRequest(MessageContainer* requestContainer)
{

    uint32_t status = PASSED;
    MessageContainer responseContainer;

    StubI2CRequest* request = stub_i2_crequest__unpack(NULL, requestContainer->data.len, requestContainer->data.data);
              
    StubI2CResponse response =   STUB_I2_CRESPONSE__INIT;
	
	response.i2cid = request->i2cid;
	response.has_i2cid = true;

	response.readbyte = I2C_control(request->i2cid, request->slaveaddress, request->readorwrite,request->bytetowrite );
	response.has_readbyte= true;
/*
	//--------------------------

    response.readbyte = I2C_control(request->i2cid, request->slaveaddress, request->readorwrite,request->bytestwrite[0]);
    response.has_readbyte= true;

	uint32_t I2C_W_buf[256] = {0},i;

	for(i = 0; i < request->n_bytestwrite;i++)
	{
	    I2C_W_buf[i] = request->bytestwrite[i];
	}

	response.readbytes = I2C_W_buf;
	response.n_readbytes = request->n_bytestwrite;

	//-------------------------------
*/
	status_response(status,&response.status, &response.statusword ,&response.has_statusword);

    responseContainer = createContainer(MESSAGE_TYPE__StubI2CResponse, requestContainer->token, true, &response, &stub_i2_cresponse__pack, &stub_i2_cresponse__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_i2_crequest__free_unpacked(request,NULL);

}


void Stub_I2CWriteBytesRequest(MessageContainer* requestContainer)
{

    uint32_t status = PASSED;
    MessageContainer responseContainer;

    StubI2CWriteBytesRequest* request = stub_i2_cwrite_bytes_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    StubI2CWriteBytesResponse response =   STUB_I2_CWRITE_BYTES_RESPONSE__INIT;

    response.i2cid = request->i2cid;
    response.has_i2cid = true;
    response.slaveaddress = request->slaveaddress;
    response.has_slaveaddress = true;

//    if(request->i2cid != 0xFEED)//BTSR FEEDR (Script identification)
//    {
//
//        //response.readbyte = I2C_control(request->i2cid, request->slaveaddress, request->readorwrite,request->bytetowrite );
//        //response.has_readbyte= true;
//
//        //--------------------------
//
//        //response.readbyte = I2C_control(request->i2cid, request->slaveaddress, request->readorwrite,request->bytestwrite[0]);
//        //response.has_readbyte= true;
//
//        uint8_t I2C_W_buf[256] = {0},i;
//
//        for(i = 0; i < request->n_bytestwrite;i++)
//        {
//            I2C_W_buf[i] = (uint8_t)(request->bytestwrite[i] & 0xff);
//        }
//
//        //response.readbytes = I2C_W_buf;
//        //response.n_readbytes = request->n_bytestwrite;
//
//        //-------------------------------
//
//
//        //----------------------
//
//        status = I2C_Write/*Write_I2C*/(request->i2cid, request->slaveaddress, I2C_W_buf, request->n_bytestwrite);
//
//    }
//    else
//    {
//        //--------------- RS485 BTSR FEEDR ---------------
//
//
//        uint8_t BTSR_TX_Buff[Max_BTSR_TX_Bytes] = {0},i;
//
//        for(i = 0; i < request->n_bytestwrite;i++)
//        {
//            BTSR_TX_Buff[i] = (uint8_t)(request->bytestwrite[i] & 0xff);
//        }
//
//        CODE_STRING = BTSR_TX_Buff[0];
//        Function_Code = BTSR_TX_Buff[1];
//
//        if(request->slaveaddress)//Auto_Calc_CheckSum
//        {
//            BTSR_Calculate_CheckSum(BTSR_TX_Buff,request->n_bytestwrite);
//            BTSR_Send_Buf(BTSR_TX_Buff, request->n_bytestwrite + 2);//2 bytes of CheckSum
//        }
//        else
//        {
//            BTSR_Send_Buf(BTSR_TX_Buff, request->n_bytestwrite);
//        }
//
//        Task_sleep (10);
//        BTSR_RECEIVE_Buf(BTSR_RX_Buff, 0);//size not in use (need to ignore the returned error)
//
//
//    }
    if((request->i2cid != 0xFEED) && (request->i2cid != 0xFEED3ADD))//BTSR FEEDR (Script identification)
    {

        //response.readbyte = I2C_control(request->i2cid, request->slaveaddress, request->readorwrite,request->bytetowrite );
        //response.has_readbyte= true;

        //--------------------------

        //response.readbyte = I2C_control(request->i2cid, request->slaveaddress, request->readorwrite,request->bytestwrite[0]);
        //response.has_readbyte= true;

        uint8_t I2C_W_buf[256] = {0},i;

        for(i = 0; i < request->n_bytestwrite;i++)
        {
            I2C_W_buf[i] = (uint8_t)(request->bytestwrite[i] & 0xff);
        }

        //response.readbytes = I2C_W_buf;
        //response.n_readbytes = request->n_bytestwrite;

        //-------------------------------


        //----------------------

        status = I2C_Write/*Write_I2C*/(request->i2cid, request->slaveaddress, I2C_W_buf, request->n_bytestwrite);

    }
    else
    {
        //--------------- RS485 BTSR FEEDR ---------------


        uint8_t BTSR_TX_Buff[Max_BTSR_TX_Bytes] = {0},i;

        for(i = 0; i < request->n_bytestwrite;i++)
        {
            BTSR_TX_Buff[i] = (uint8_t)(request->bytestwrite[i] & 0xff);
        }

        CODE_STRING = BTSR_TX_Buff[0];

        if(request->i2cid == 0xFEED3ADD)//Only for commands with 3 bytes with Address 1 (0x06/0xFD)
        {

            Function_Code = BTSR_TX_Buff[4];

            BTSR_Send_Buf_3xADD1(BTSR_TX_Buff, request->n_bytestwrite);
        }
        else
        {
            Function_Code = BTSR_TX_Buff[1];

            if(request->slaveaddress)//Auto_Calc_CheckSum
            {
                BTSR_Calculate_CheckSum(BTSR_TX_Buff,request->n_bytestwrite);
                BTSR_Send_Buf(BTSR_TX_Buff, request->n_bytestwrite + 2);//2 bytes of CheckSum
            }
            else
            {
                BTSR_Send_Buf(BTSR_TX_Buff, request->n_bytestwrite);
            }
        }
        //Task_sleep (10);
        //BTSR_RECEIVE_Buf(BTSR_RX_Buff, 0);//size not in use (need to ignore the returned error)


    }

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

    responseContainer = createContainer(MESSAGE_TYPE__StubI2CWriteBytesResponse, requestContainer->token, true, &response, &stub_i2_cwrite_bytes_response__pack, &stub_i2_cwrite_bytes_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_i2_cwrite_bytes_request__free_unpacked(request,NULL);

}

void Stub_I2CReadBytesRequest(MessageContainer* requestContainer)
{
    uint8_t I2C_R_buf[256] = {0},i;
    uint32_t I2C_R32_buf[256] = {0};

    uint32_t status = PASSED;
    MessageContainer responseContainer;

    StubI2CReadBytesRequest* request = stub_i2_cread_bytes_request__unpack(NULL, requestContainer->data.len, requestContainer->data.data);

    StubI2CReadBytesResponse response =   STUB_I2_CREAD_BYTES_RESPONSE__INIT;

    response.i2cid = request->i2cid;
    response.has_i2cid = true;
    response.slaveaddress = request->slaveaddress;
    response.has_slaveaddress = true;

    if(request->i2cid != 0xFEED)//BTSR FEEDR (Script identification)
    {

        status = I2C_Read/*Read_I2C*/(request->i2cid, request->slaveaddress, I2C_R_buf, request->numberofbytestoread);

        //response.readbyte = I2C_control(request->i2cid, request->slaveaddress, request->readorwrite,request->bytetowrite );
        //response.has_readbyte= true;

        //--------------------------

        //response.readbyte = I2C_control(request->i2cid, request->slaveaddress, request->readorwrite,request->bytestwrite[0]);
        //response.has_readbyte= true;

        //uint32_t I2C_W_buf[256] = {0},i;

        for(i = 0; i < request->numberofbytestoread;i++)
        {
            I2C_R32_buf[i]= (uint32_t)I2C_R_buf[i] ;
        }


        response.readbytes = I2C_R32_buf;
        response.n_readbytes = request->numberofbytestoread;

        //-------------------------------
    }
    else
    {
        //--------------- RS485 BTSR FEEDR ---------------
        for(i = 0; i < request->numberofbytestoread - request->slaveaddress;i++)
        {
            I2C_R32_buf[i]= (uint32_t)BTSR_RX_Buff[i] ;
        }

        if(((request->numberofbytestoread- request->slaveaddress) > 2) && (request->slaveaddress))//Verify_Received_CheckSum
        {
            I2C_R32_buf[i] = Check_Received_CheckSum(CODE_STRING, Function_Code, BTSR_RX_Buff, (request->numberofbytestoread - request->slaveaddress));//use the next byte to return the checksum status
        }
        response.readbytes = I2C_R32_buf;
        response.n_readbytes = request->numberofbytestoread;
    }


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

    responseContainer = createContainer(MESSAGE_TYPE__StubI2CReadBytesResponse, requestContainer->token, true, &response, &stub_i2_cread_bytes_response__pack, &stub_i2_cread_bytes_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_i2_cread_bytes_request__free_unpacked(request,NULL);
}