#include "simpleBouton.h"

struct struct_code {
  uint16_t caractere : 7;  // Code ASCII (7 bits)
  uint16_t longueur : 3;     // Longueur du code Morse (3 bits)
  uint16_t code : 6;       // Code Morse (6 bits) - le point est représenté par un 1 - le trait par un 0
};

const struct_code codeMorse[] PROGMEM = { // soit 38 éléments - pour chaque caractère j'ai mis la représentation graphique
  { 'A', 2, 0b10 },    // .-    (2)       // ainsi que la valeur décimale de la valeur binaire
  { 'B', 4, 0b0111 },  // -...  (7)
  { 'C', 4, 0b0101 },  // -.-.  (5)
  { 'D', 3, 0b011 },   // -..   (3)
  { 'E', 1, 0b1 },     // .     (1)
  { 'F', 4, 0b1101 },  // ..-.  (13)
  { 'G', 3, 0b001 },   // --.   (1)
  { 'H', 4, 0b1111 },  // ....  (15)
  { 'I', 2, 0b11 },    // ..    (3)
  { 'J', 4, 0b1000 },  // .---  (8)
  { 'K', 3, 0b010 },   // -.-   (2)
  { 'L', 4, 0b1011 },  // .-..  (11)
  { 'M', 2, 0b00 },    // --    (0)
  { 'N', 2, 0b01 },    // -.    (1)
  { 'O', 3, 0b000 },   // ---   (0)
  { 'P', 4, 0b1001 },  // .--.  (9)
  { 'Q', 4, 0b0010 },  // --.-  (2)
  { 'R', 3, 0b101 },   // .-.   (5)
  { 'S', 3, 0b111 },   // ...   (7)
  { 'T', 1, 0b0 },     // -     (0)
  { 'U', 3, 0b110 },   // ..-   (6)
  { 'V', 4, 0b1110 },  // ...-  (14)
  { 'W', 3, 0b100 },   // .--   (4)
  { 'X', 4, 0b0110 },  // -..-  (6)
  { 'Y', 4, 0b0100 },  // -.--  (4)
  { 'Z', 4, 0b0011 },  // --..  (3)
  { '0', 5, 0b00000 }, // ----- (0)
  { '1', 5, 0b10000 }, // .---- (16)
  { '2', 5, 0b11000 }, // ..--- (24)
  { '3', 5, 0b11100 }, // ...-- (28)
  { '4', 5, 0b11110 }, // ....- (30)
  { '5', 5, 0b11111 }, // ..... (31)
  { '6', 5, 0b01111 }, // -.... (15)
  { '7', 5, 0b00111 }, // --... (71)
  { '8', 5, 0b00011 }, // ---.. (3)
  { '9', 5, 0b00001 }, // ----. (1)
  { ',', 6, 0b110111}, // ..-... (55)
  { '.', 6, 0b010101}, // -.-.-. (21)
};

const uint32_t tempsMaximum = 250; 
const uint32_t tempsMinimum = 100;
//const uint8_t margeDeHausse = 10;
uint32_t temps = 150; //200 debutant

constexpr   uint32_t point (uint32_t t) {
  return  t;
}

constexpr   uint32_t trait (uint32_t t) {
  return  3 * t;
}

constexpr   uint32_t silenceEntreLettres (uint32_t t) {
  return  3 * t;
}

constexpr   uint32_t seuilDePriseEnCompte (uint32_t t) { //permet la prise en compte de l'unité de temps jusqu'à seuil
  return  7 * t;
}

constexpr   uint32_t silenceEntreMots (uint32_t t) {
  return  9 * t;
}

const uint8_t  buzzer = A0;

bool stop;
bool stable;


simpleBouton bouton(5);

//Cablage : pin---BP---GND

uint32_t valeurMediane [57];

void setup()
{
  pinMode(buzzer, OUTPUT);
  digitalWrite(buzzer, LOW) ;
  Serial.begin(115200);
}

void loop()
{
  static uint8_t codeMorseRecu [6];
  static uint8_t x = 0; // pour l'incrémentation de valeurMediane
  static uint8_t y = 0; // pour l'incrémentation de codeMorseRecu

  uint32_t duree = bouton.dureeEnfonce(); // permet de determiner la durée d'un point ou d'un trait
  uint32_t espace = bouton.dureeRelache(); // isole la valeur de Temps

  bouton.actualiser();



  if (duree == 0)  digitalWrite(buzzer, LOW) ;
  else if (duree != 0) digitalWrite(buzzer, HIGH) ;

  if (bouton.vientDEtreEnfonce() && (espace <= seuilDePriseEnCompte(temps) )) { // Recupère les silences jusqu'à ce seuil
    valeurMediane[x] = espace;
    x++;
    if (x == 56)  {
      algorithmeT(valeurMediane);
      x = 0;
    }
  }

  if (bouton.vientDEtreRelache()) {
    stop = true;
    stable = true;
    if (duree <= point(temps)) {
      codeMorseRecu[y] = 1 ;
    } else if (duree > point(temps) && duree <= trait(temps)) {
      codeMorseRecu[y] = 0 ;
    }
    y++;
  }

  if ((stop) && bouton.estRelacheDepuisPlusDe(silenceEntreLettres(temps))) {
    stop = false;
    char caractere = decodeMorse(codeMorseRecu, y);
    Serial.print(caractere);
    y = 0;
  }  else if ((stable) && bouton.estStableDepuisPlusDe(silenceEntreMots(temps))) {
    stable = false;
    Serial.println(" ");
    displayMedianTab(x);
  }

}


void displayMedianTab(uint8_t x) {
  Serial.print("x:");Serial.println(x);
    for(int a=0; a< sizeof(valeurMediane)/4; a++) {
      Serial.print(valeurMediane[a]);Serial.print(",");
    }
    Serial.println();
}

// Fonction pour décoder le Morse
char decodeMorse( uint8_t* tableau, uint8_t longueur) {
  uint8_t codeBinaire = convertirTableauEnEntier(tableau, longueur);

  for (uint8_t i = 0; i < sizeof(codeMorse) / sizeof(struct_code); i++) {
    struct_code code = lireDepuisProgmem(i); // lit la structure depuis la mémoire FLASH
    if (code.longueur == longueur && code.code == codeBinaire) {
      return static_cast<char>(code.caractere);
    }
  }
  return '?'; // Retourne '?' si aucune correspondance n'est trouvée
}

// Fonction pour convertir un tableau de bits en entier binaire
uint8_t convertirTableauEnEntier(uint8_t* tableau, uint8_t longueur) {
  uint8_t resultat = 0;
  for (uint8_t i = 0; i < longueur; i++) {
    resultat = (resultat << 1) | tableau[i]; // On décale resultat de 1 bit à gauche et on ajoute les bits successifs
  }
  return resultat; // resultat est transformé automatiquement en décimal
}
// Fonction pour lire la  structure depuis la mémoire FLASH
struct_code lireDepuisProgmem(uint8_t index) {
  struct_code temp;
  memcpy_P(&temp, &codeMorse[index], sizeof(struct_code)); // Copie depuis le FLASH vers la RAM
  return temp;
}

void algorithmeT(uint32_t tab[])
{
  uint32_t median = mediane(tab);
  if (median > tempsMinimum && median <= tempsMaximum) temps = median;
  Serial.print('\n');
  Serial.print("temps médian : "); Serial.println(median);
}
uint32_t mediane(uint32_t tabTrie[]) { //trie à bulles
  for (uint8_t i = 0; i < 58; i++) {
    for (uint8_t j = 0; j < 58 - i - 1; j++) {
      if (tabTrie[j] > tabTrie[j + 1]) {
        // Échange des éléments
        uint32_t temp = tabTrie[j];
        tabTrie[j] = tabTrie[j + 1];
        tabTrie[j + 1] = temp;
      }
    }
  }
  for (uint8_t z = 0; z < 58; z++) {
    Serial.print('\n');Serial.print("nmr : ") ;Serial.print(z) ;Serial.print('\t'); Serial.println(tabTrie[z]) ;
  }
  return tabTrie[28]; //mediane
}