// https://programmersqtcpp.blogspot.com/2022/07/arduino-sketch-multi-file.html
//#include "config.h"
//#include "extern.h"
#include "helperfunc.h"
#include <LiquidCrystal.h>
byte miaVar = 0;
LiquidCrystal lcd(12, 11, 10, 9, 8, 7);

byte byteArray[] = { 0x17, 0x0A, 0xE1, 0x56
                   , 0x2E, 0x02, 0x00, 0x00
                   , 0x00, 0x00, 0x00, 0x00
                   , 0x00, 0x00, 0x00, 0x00
                   , 0x00, 0x00, 0x00 };

byte byteArrayDec[] = { 23, 10, 225, 86, 46
                      , 2, 0, 0, 0, 0, 0, 0
                      , 0, 0, 0, 0, 0, 0, 0};

// sizeof restituisce la dimensione in byte di byteArray                   
const size_t len_byteArray = sizeof(byteArray);
const size_t len_byteArrayDec = sizeof(byteArrayDec);

char bHex[3];
// len_byteArray deve essere const, diversamente non compila
char assembla[(len_byteArray * 2)+1];
// 19 x 2 + 1 = 39 byte incluso il terminatore

char stringa[] = "17 0A xx xx xx xx 00 00 00 00 00 00 00 00 00 00 00 00 00";
//char stringa[] = "170Axxxxxxxx00000000000000000000000000";
byte uidByte0[] = { 0xE1, 0x56, 0x2E, 0x02 };
byte uidByte1[] = { 0x56, 0xE1, 0x2E, 0x02 };
byte uidByte2[] = { 0x02, 0xE1, 0x2E, 0x56 };


void faiPacchetto(uint8_t *uid) {
    //char *lcptr = &stringa[6]; 
    /*for (byte i = 0; i < 4; i++) {
        sprintf(lcptr, "%02X", uid[i]);
        lcptr += 2;
        *lcptr = 0x20;
        lcptr++;
    }*/
    // Ancora meglio
#if (1)    
    // con gli spazi
    //char *lcptr = &stringa[6]; 
    sprintf(&stringa[6], "%02X %02X %02X %02X"
    , uid[0], uid[1], uid[2], uid[3]);
    stringa[17] = ' '; // sovrascrive il terminatore aggiunto da sprintf
#else
    // senza spazi
    //char *lcptr = &stringa[4]; 
    sprintf(&stringa[4], "%02X%02X%02X%02X"
    , uid[0], uid[1], uid[2], uid[3]);
    stringa[12] = '0'; // sovrascrive il terminatore aggiunto da sprintf
#endif 
}

void setup()
{
    Serial.begin(115200);
    bip();
    biip();
    lcd.begin(16, 2);
    Serial.println(stringa);
    faiPacchetto(uidByte0);
    Serial.println(stringa);
    faiPacchetto(uidByte1);
    Serial.println(stringa);
    faiPacchetto(uidByte2);
    Serial.println(stringa);
    String str(stringa);
    Serial.println(str);




    #if(0)
    // ptr punta ad assembla
    char *ptr = assembla;

    Serial.println(len_byteArray);

    //  converte ogni byte di byteArray in una 
    //  c string valida di nome bHex.
    //  Stampa bHex con print.
    // Durante il for concateno bHex dentro la 
    // c string di nome assembla.
    Serial.println("Converte, stampa e concatena:");
    for (byte i=0; i < len_byteArray; i++) {
        sprintf(bHex, "%02X", byteArray[i]);
        Serial.print(bHex);
        Serial.print(" ");
        sprintf(ptr, "%s", bHex);
        // ptr punta ad ptr + 2
        ptr += 2;
    }
    // Attenzione che ora ptr punta fuori da aera allocata
    // cioè non puoi usarlo da qui in poi.
    Serial.println();
    Serial.println("Stampa la c string assembla:");
    Serial.println(assembla);

    // stampa i byte di assembla in formato hex
    // incuso il terminatore di c string
    Serial.println("Stampa i 38 + 1 byte di assembla, incluso il terminatore:");
    for (byte i=0; i<strlen(assembla) + 1; i++) {
        sprintf(bHex, "%02X", (uint8_t)assembla[i]);
        Serial.print(bHex);
        Serial.print(" ");
    }

    Serial.println("\n");
    Serial.println("Ripeto tutto ma uso byteArrayDec");
    Serial.println("Converte, stampa e concatena:");
    ptr = assembla;  
    for (byte i=0; i < len_byteArrayDec; i++) {
        sprintf(bHex, "%02X", byteArrayDec[i]);
        Serial.print(bHex);
        Serial.print(" ");
        sprintf(ptr, "%s", bHex);
        // ptr punta ad ptr + 2
        ptr += 2;
    }

    // Attenzione che ora ptr punta fuori da aera allocata
    // cioè non puoi usarlo da qui in poi.
    Serial.println();
    Serial.println("Stampa la c string assembla:");
    Serial.println(assembla);

    // stampa i byte di assembla in formato hex
    // incuso il terminatore di c string
    Serial.println("Stampa i 38 + 1 byte di assembla, incluso il terminatore:");
    for (byte i=0; i<strlen(assembla) + 1; i++) {
        sprintf(bHex, "%02X", (uint8_t)assembla[i]);
        Serial.print(bHex);
        Serial.print(" ");
    }
    Serial.println("\n");

    // Se serve uno spazio di separazione ogni due caratteri
    // allora mi serve un buffer grande 38 + (19 - 1) + 1
    Serial.println("Converte e concatena:");
    char localBuffer[38 + 19] = {0};
    char *lptr = localBuffer;  

    for (byte i=0; i < len_byteArray; i++) {
        sprintf(bHex, "%02X", byteArray[i]);
        
        if (i < 18) {
            sprintf(lptr, "%s ", bHex);
            // ptr punta ad ptr + 2
            lptr += 3;
        } else {
            sprintf(lptr, "%s", bHex);
        }
    }

    Serial.println(localBuffer);
    // C'è un passaggio inutile, non serve passare prima
    // da bHex.
    // Puliamo il buffer anche se non serve.
    memset(localBuffer, 0, 38 + 19);
    lptr = localBuffer;
    for (byte i=0; i < len_byteArray; i++) {
        if (i < 18) {
            sprintf(lptr, "%02X ", byteArray[i]);
            lptr += 3;
        } else {
            sprintf(lptr, "%02X", byteArray[i]);
        }
    }
    Serial.println(localBuffer);

    // certo che è assurdo tutto sto giro tondo quando
    // ciò che cambia in localBuffer sono i seguenti 
    // indici: (6,7) (9,10) (12,13) (15,16)
    // 17 0A E1 56 2E 02 00 00 00 00 00 00 00 00 00 00 00 00 00
    // quindi è suffiente dichiarare una c string ad es.
    byte uidByte[] = { 0xE1, 0x56, 0x2E, 0x02 };
    char message[] = { '1', '7', ' ', '0', 'A'
                     , ' ', 'x', 'x', ' ', 'x'
                     , 'x', ' ', 'x', 'x', ' ', 'x', 'x', '\0'};
    Serial.println(message);
    //char *lcptr = &message[6]; 
    // solo questo può cambiare non ha senzo tutte le volte
    // ricreare la stringa str.
    ///Serial.println(lcptr);
    /*for (byte i = 0; i < 4; i++) {
        sprintf(lcptr, "%02X", uidByte[i]);
        lcptr += 2;
        if (i < 3) {
            *lcptr = 0x20;
            lcptr++;
        }
    }*/
    #endif
    /*Serial.println(stringa);
    faiPacchetto(uidByte);
    Serial.println(stringa);*/
    
} // end void setup()




void loop() {

  
  
    
} // end void loop()