/*

*/

// global variable to keep the results from onReceive()
#include <BluetoothSerial.h>
#include <NRC_UDS_protocol.h>
#define buffersize 50
#define baudrate 9600

// The Modbus RTU standard prescribes a silent period corresponding to 3.5 characters between each
// message, to be able to figure out where one message ends and the next one starts.
#define modbusRxTimeoutLimit 4


//PWM Definitions
#define SW_versionMajor 0x01
#define SW_versionMinor 0x01
#define LEDC_CHANNEL_0 0
#define LEDC_TIMER_13_BIT 13
#define LEDC_BASE_FREQ 5000
#define LED_PIN 2

#define Timer_pending_cyclic_maxvalue 1000
#define Timer_timeout_Maxvalue        3000

#define HEXCODE_BIT1_READ_SENSOR_1 0x31
#define HEXCODE_BIT1_READ_SENSOR_2 0x32
#define HEXCODE_BIT1_READ_SENSOR_3 0x33

#define HEXCODE_BIT1_WRITE_CHANNEL_1 0x31
#define HEXCODE_BIT1_WRITE_CHANNEL_2 0x32
#define HEXCODE_BIT1_WRITE_CHANNEL_3 0x33

#define HEXCODE_BIT1_READ_DEBUG      0xFF
#define HEXCODE_BIT1_WRITE_DEBUG     0xFF
#define HEXCODE_BIT1_WRITE_NAME      0xFE


uint8_t length_of_name                  = 0;
uint8_t BT_rx_buffer[buffersize];
uint8_t uart_buffer[buffersize];
uint16_t timer_pending                  = 0;
uint16_t timer_timeout                  = 0;

bool pendingSend                        = false;
bool isChipPendingActive                = false;
bool IsBTDebugOn                        = false;
String deviceName                       = "BT_Radio_66";

BluetoothSerial SerialBT;



// UART_RX_IRQ will be executed as soon as data is received by the UART and an RX Timeout occurs
// This is a callback function executed from a high priority monitor task
// All data will be buffered into RX Buffer, which may have its size set to whatever necessary

void fill_UART_RX_Buffer()
{
  uint8_t i=0;
  while (Serial.available()) 
  {
    uart_buffer[i]=(uint8_t)Serial.read();
    i=i+1;
  }
  i=0;
}


void fill_BT_RX_Buffer()
{
  uint8_t tempCnt = 0;
  while (SerialBT.available())
  {
    BT_rx_buffer[tempCnt]= SerialBT.read();
    tempCnt = tempCnt +1;
  }
  tempCnt=0;
}

void sendDebugOutput(String text)
{
  if(IsBTDebugOn)
  {
    int i;
    for (i=0;i<text.length();i++)
    {
      SerialBT.write(text[i]);
    }
  }
}

// setup() and loop() are functions executed by a low priority task
// Therefore, there are 2 tasks running when using onReceive()
void setup() 
{
  // Using Serial0 will work in any case (using or not USB CDC on Boot)
#if CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2
  // UART_CLK_SRC_APB will allow higher values of RX Timeout
  // default for ESP32 and ESP32-S2 is REF_TICK which limits the RX Timeout to 1
  // setClockSource() must be called before begin()
  Serial.setClockSource(UART_CLK_SRC_APB);
#endif
  // the amount of data received or waiting to be proessed shall not exceed this limit of 1024 bytes
  Serial.setRxBufferSize(buffersize);  // default is 256 bytes
  SerialBT.begin(deviceName);
  Serial.begin(baudrate);        // default pins and default mode 8N1 (8 bits data, no parity bit, 1 stopbit)

  // set RX Timeout based on UART symbols ~ 3.5 symbols of 11 bits (MODBUS standard) ~= 2 ms at 19200
  Serial.setRxTimeout(modbusRxTimeoutLimit);  // 4 symbols at 19200 8N1 is about 2.08 ms (40 bits)
  // sets the callback function that will be executed only after RX Timeout
  //Serial0.onReceive(UART0_RX_CB, true);
  
}




void analyse_BT_Protocol(uint8_t receive_BT_Array[])
{
    sendDebugOutput("analyse_BT_Protocol called");
    
    /*Command to read something*/
    if (receive_BT_Array[0]==UDS_READ_DATA)
    {
	    uint8_t temp = (UDS_READ_DATA + 0x40);
      sendDebugOutput("In Bit0 UDS_READ_DATA Condition");
      switch(receive_BT_Array[1])
      {
        case HEXCODE_BIT1_READ_SENSOR_1:
          SerialBT.write(temp);
          SerialBT.write(HEXCODE_BIT1_READ_SENSOR_1);
          SerialBT.write(0xAA);
          SerialBT.write(0xAA);
          break;

        case HEXCODE_BIT1_READ_SENSOR_2:
          SerialBT.write(temp);
          SerialBT.write(HEXCODE_BIT1_READ_SENSOR_2);
          SerialBT.write(0xBB);
          SerialBT.write(0xBB); 
          break;

        case HEXCODE_BIT1_READ_SENSOR_3:
          SerialBT.write(temp);
          SerialBT.write(HEXCODE_BIT1_READ_SENSOR_3);
          SerialBT.write(0xCC);
          SerialBT.write(0xCC); 
          break;

        case HEXCODE_BIT1_READ_IDENT:
          /* 0x22 0xF1 0xAB */
          if(receive_BT_Array[2]==0xAB)
          {
            SerialBT.write(SW_versionMajor);
            SerialBT.write(' ');
            SerialBT.write(SW_versionMinor);
          }
          break;

        case HEXCODE_BIT1_READ_DEBUG:
          SerialBT.write(temp);
          SerialBT.write(HEXCODE_BIT1_READ_DEBUG);
          SerialBT.write(IsBTDebugOn);
          break;

        default:
          SerialBT.write(0x7F);
          SerialBT.write(UDS_READ_DATA);
          SerialBT.write(UDS_NRC_requestOutOfRange);
          sendDebugOutput("Default switchcase of BIT0 Read");
      }
    }
    /*Command to write something*/
    else if(receive_BT_Array[0] == UDS_WRITE_DATA)
    {
      uint8_t temp = (UDS_WRITE_DATA + 0x40);
      sendDebugOutput("In Bit0 UDS_WRITE_DATA Condition");
      switch(receive_BT_Array[1])
      {
        /* This part should change the name of the BT Module*/
        /* 0x2E 0xFE 0x05 0x!! 0x!!  0x!! 0x!! 0x!!......*/
        case HEXCODE_BIT1_WRITE_NAME:
          length_of_name= receive_BT_Array[2];
          if((0<length_of_name) && (length_of_name<=20))
          {
            String newName="";
            uint8_t j;
            for(j=0;j<length_of_name;j++)
            {
              newName = newName + (char)receive_BT_Array[j+3];
            }
            //sendDebugOutput("change BT name to"); 
            //sendDebugOutput(newName);
            SerialBT.write(temp);
            SerialBT.write(HEXCODE_BIT1_WRITE_NAME); 
            deviceName=newName;
            newName="";
            SerialBT.begin(deviceName);
            sendDebugOutput("Devicename is now"+deviceName);
          
          }else{
            SerialBT.write(0x7F);
            SerialBT.write(UDS_WRITE_DATA);
            SerialBT.write(UDS_NRC_incorrectMessageLengthOrInvalidFormat);
          }
          break;  


        /*This Part enables and disables Debugmode*/
        /* 0x2E 0xFF 0x01 */
        /* 0x2E 0xFF 0x00 */
        case HEXCODE_BIT1_WRITE_DEBUG:
            sendDebugOutput("In Bit1 HEXCODE_BIT1_WRITE_DEBUG Condition");
            if(receive_BT_Array[2]==0x01)
            {
                    IsBTDebugOn=true;
                    SerialBT.write(temp);
                    SerialBT.write(HEXCODE_BIT1_WRITE_DEBUG);
                    SerialBT.write(0x01);
            }
            else if(receive_BT_Array[2]==0x00)
            {
                    IsBTDebugOn=false;
                    SerialBT.write(temp);
                    SerialBT.write(HEXCODE_BIT1_WRITE_DEBUG);
                    SerialBT.write(0x00);
            }
            break;

        case HEXCODE_BIT1_WRITE_CHANNEL_1:
            break;
        case HEXCODE_BIT1_WRITE_CHANNEL_2:
            break;
        case HEXCODE_BIT1_WRITE_CHANNEL_3:
            break;
        default:
          SerialBT.write(0x7F);
          SerialBT.write(UDS_WRITE_DATA);
          SerialBT.write(UDS_NRC_requestOutOfRange);
          sendDebugOutput("Default switchcase of BIT0 Write");
      }

    }
     /*Command to send something to another Chip */
    else if(receive_BT_Array[0] == UDS_ROUTING)
    {
      
   
       SerialBT.write('R');
       SerialBT.write('o');
       SerialBT.write('u');
       SerialBT.write('t');
       SerialBT.write('i');
       SerialBT.write('n');
       SerialBT.write('g');
       SerialBT.write(' ');
       SerialBT.write('A');
       SerialBT.write('t');
       SerialBT.write('m');
       SerialBT.write('e');
       SerialBT.write('g');
       SerialBT.write('a');
       SerialBT.write('8');
       SerialBT.write('8');

       SerialBT.write('X');
       SerialBT.write(' ');
       
       Serial.write(receive_BT_Array[1]);
       Serial.write(receive_BT_Array[2]);
       if(Serial.available())
       {
           char c = Serial.read();
           SerialBT.write(c);
       }

    
       SerialBT.write(' ');
       SerialBT.write('X');

       
       /*
       isChipPendingActive = true;

       if((isChipPendingActive == true)&&(pendingSend == false))
       {
        SerialBT.write(0x7F);
        SerialBT.write(UDS_ROUTING);
        SerialBT.write(UDS_NRC_ResponsePending);
        pendingSend = true;
       }
       */
	  }
}


void delete_BT_UART_buffer()
{
  for(int z=0;z<buffersize;z++)
  {
    BT_rx_buffer[z]=0x00;  
    uart_buffer[z]=0x00;
  }
}

void updateTimer()
{
    if(isChipPendingActive == true)
    {
      if( (timer_pending >=Timer_pending_cyclic_maxvalue))
      {
        /*reset bit so in next cycle the pending messase is send after Timer_pending_cyclic */
        pendingSend = false;
        timer_pending=0;
      }else{
        timer_pending++;
      }
    }else
    {
      timer_pending=0;
    }

    if(isChipPendingActive == true)
    {
      if( (timer_timeout >=Timer_timeout_Maxvalue))
      {
        SerialBT.write(0x7F);
        SerialBT.write(UDS_ROUTING);
        SerialBT.write(UDS_NRC_uploadDownloadNotAccepted);
        timer_timeout=0;
        isChipPendingActive=false;
      }else{
        timer_timeout++;
      }
    }else
    {
      timer_timeout=0;
    }
}

void loop() {
  // String <uart_buffer> is filled by the UART Callback whenever data is received and RX Timeout occurs
  
  fill_BT_RX_Buffer();
  //analyse_uart_Protocol(uart_buffer);
  analyse_BT_Protocol(BT_rx_buffer);
  
  delete_BT_UART_buffer();
  updateTimer();
  delay(1);
}