#include "DigitalClass.h"
#include "AnalogClass.h"

#define DIGITAL_ARRAY_SIZE 8
#define ANALOG_ARRAY_SIZE 4
#define PULSE_ARRAY_SIZE 2

#define ANALOG_MAX_HEX_STRING_LENGTH 5
#define PULSE_MAX_HEX_STRING_LENGTH 5

uint8_t digitalInput[DIGITAL_ARRAY_SIZE] = {2, 3, 4, 5, 6, 7, 8, 9};
uint8_t digitalLed[DIGITAL_ARRAY_SIZE] = {23, 22, 25, 24, 27, 26, 29, 28};
uint8_t switchPin[DIGITAL_ARRAY_SIZE] = {31, 30, 33, 32, 35, 34, 37, 36};

uint8_t analogInput[ANALOG_ARRAY_SIZE] = {A0, A1, A2, A3};
uint8_t analogLed[ANALOG_ARRAY_SIZE] = {38, 39, 40, 41};


DigitalClass digitaInputArray[DIGITAL_ARRAY_SIZE];
AnalogClass analogInputArray[ANALOG_ARRAY_SIZE];

DigitalClass digitalIn(9, 23, 31);

unsigned long timerSendData;

void setup() {
  Serial.begin(19200);
  analogReference(INTERNAL2V56);
  for (int i = 0; i < DIGITAL_ARRAY_SIZE; i++) {
    digitaInputArray[i].settings(digitalInput[i], digitalLed[i], switchPin[i]);
  }
  for (int i = 0; i < ANALOG_ARRAY_SIZE ; i++) {
    analogInputArray[i].settings(analogInput[i], analogLed[i]);
  }

}

void loop() {
  processDigitalInput();
  processAnalogInput();
  if (millis() - timerSendData > 1000) {
    sendData();
    timerSendData = millis();
  }
}

void processAnalogInput() {
  for (int i = 0; i < ANALOG_ARRAY_SIZE; i++) {
    analogInputArray[i].readInput();
  }
}
void processDigitalInput() {
  for (int i = 0; i < DIGITAL_ARRAY_SIZE; i++) {
    digitaInputArray[i].readInput();
  }
}

void sendData() {
  uint8_t size = 150;
  char buffer[size] = {0};
  if (makeStringToSend(buffer, size)) {
    Serial.println(buffer);
  }
  else {
    Serial.println("buffer za maly!!!");
  }
}
uint8_t getDigitalValue() {
  unsigned int value = 0;
  for (int i = 0; i < DIGITAL_ARRAY_SIZE ; i++) {
    if (digitaInputArray[i].getInputState()) {
      value |= (1 << (i));
    }
  }
  return value;
}
bool getAnalogValueString(char *buffer, const unsigned int bufferSize) {
  for (int i = 0; i < ANALOG_ARRAY_SIZE; i++) {
    char temp[5];
    snprintf(temp, sizeof(temp), "%X", analogInputArray[i].getAnalogValue());
    strcat(buffer, temp);
    if (strlen(buffer) + strlen(temp) + 1 >= bufferSize) {
      Serial.println("Buffer jest za maly !!!!");
      return false;
    }
    if (i < ANALOG_ARRAY_SIZE - 1 ) {
      strcat(buffer, ".");
    }
  }
  return true;
}
bool getPulseValueString(char *buffer, const unsigned int bufferSize) {
  // TO DO :
  //implement logica hier 
  strcpy(buffer,"AAA.BBB");
  return true;
}

bool makeStringToSend(char *buffer, uint8_t bufferSize) {
  const unsigned int analogSize = ANALOG_ARRAY_SIZE * ANALOG_MAX_HEX_STRING_LENGTH + 1;
  const unsigned int pulseSize = PULSE_ARRAY_SIZE * PULSE_MAX_HEX_STRING_LENGTH + 1;
  char tempAnalog[analogSize] = {0};
  char tempPulse[pulseSize] = {0};

  if (!getAnalogValueString(tempAnalog, analogSize)) {
    return false;
  }
  if(!getPulseValueString(tempPulse, pulseSize)){
    return false;
  }
  int writtenBytes = snprintf(buffer, bufferSize, "dataToSend : 7/0&0/%02X$%s$%s&", getDigitalValue(), tempAnalog, tempPulse );
  if (writtenBytes >= bufferSize) {
    memset(buffer, 0, bufferSize); // clear buffer
    return false;
  }
  if (!makeCheckSum(buffer, bufferSize)) {
    return false;
  }
  return true;
}
bool makeCheckSum(char* dataToSend, uint8_t bufferSize) {
  // TO DO :
  //implement logica hier 
  const char* checksumText = "AA*";
  size_t currentLength = strlen(dataToSend);
  size_t checksumLength = strlen(checksumText);

  if (currentLength + checksumLength + 1 > bufferSize) {
    return false;
  }

  strncat(dataToSend, checksumText, checksumLength);
  return true;
}