#include <Adafruit_GFX.h>
#include <Adafruit_ILI9341.h>
#include <SPI.h>
#include <IRremote.h> // Ajout de la bibliothèque IRremote.h

#define TFT_DC 2
#define TFT_CS 15
#define TFT_WIDTH 320
#define TFT_HEIGHT 240

#define IR_RECEIVE_PIN 22 // Broche GPIO pour le récepteur IR

Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC);
IRrecv irReceiver(IR_RECEIVE_PIN); // Création de l'objet IRrecv

volatile bool signalRequested = false;
volatile int requestedSignalNumber = 0;
volatile bool signalInProgress = false;

void setup() {
  Serial.begin(9600);
  tft.begin();
  tft.setRotation(1);
  tft.fillScreen(ILI9341_BLACK);
  tft.setTextColor(ILI9341_WHITE);
  tft.setTextSize(3);

  irReceiver.enableIRIn(); // Activation du récepteur IR

  attachInterrupt(digitalPinToInterrupt(IR_RECEIVE_PIN), signalInterrupt, FALLING);
}

void loop() {
  if (signalRequested && !signalInProgress) {
    signalInProgress = true;
    tft.fillScreen(ILI9341_BLACK);
    switch (requestedSignalNumber) {
      case 48:
        Serial.println("Signal 1 detected");
        drawSignal(ILI9341_YELLOW, calculateCombinedSignal1);
        break;
      case 24:
        Serial.println("Signal 2 detected");
        drawSignal(ILI9341_GREEN, calculateCombinedSignal2);
        break;
      case 122:
        Serial.println("Signal 3 detected");
        drawSignal(ILI9341_RED, calculateCombinedSignal3);
        break;
      case 16:
        Serial.println("Signal 4 detected");
        drawSignal(ILI9341_CYAN, calculateCombinedSignal4);
        break;
      default:
        Serial.println("Unknown signal detected");
        tft.fillScreen(ILI9341_BLACK); // Effacer l'écran si aucun signal reconnu
        //signalInProgress = false; // Réinitialiser signalInProgress si aucun signal reconnu
        break;
    }
    signalInProgress = false; // Réinitialiser signalRequested après avoir affiché le signal
  }
}


void signalInterrupt() {
  if (irReceiver.decode()) {
    unsigned long irValue = irReceiver.decodedIRData.command;
    irReceiver.resume();
    if (irValue != requestedSignalNumber) {
      signalRequested = true;
      requestedSignalNumber = irValue;
    }
  }
}



void drawSignal(uint16_t color, float (*calculateSignal)(int)) {
  tft.fillScreen(ILI9341_BLACK);
  int startX = 0; // Position de départ de la courbe

  while (startX < TFT_WIDTH) {
    int currentSignalNumber = requestedSignalNumber; // Stocker le numéro de signal actuel

    for (int x = startX; x < TFT_WIDTH - 1; x++) {
      float y = calculateSignal(x);
      float y_next = calculateSignal(x + 1);
      tft.drawLine(x, y, x + 1, y_next, color);

      // Vérifier si une nouvelle demande de signal est intervenue pendant le dessin
      if (signalRequested && currentSignalNumber != requestedSignalNumber) {
        return; // Sortir de la fonction immédiatement si une nouvelle demande est détectée
      }
      
    }

    startX = TFT_WIDTH; // Pour terminer la boucle externe
  }
}


float calculateCombinedSignal1(int x) {
  float s = 0;
  int offset = 1;

  while (true) { // Boucle infinie
    float onde_P = -(1 / 0.4) * exp(-pow((x - 20 - offset), 2) / pow(8, 2));
    float onde_Q = (1.4 / 0.4) * exp(-pow((x - 42 - offset), 2) / 1.5);
    float onde_R = -(4 / 0.2) * exp(-pow((x - 47.35 - offset), 2) / pow(2.5, 2));
    float onde_S = (1 / 0.2) * exp(-pow((x - 50.9 - offset), 2) / pow(1.5, 2));
    float onde_T = -(1 / 0.3) * exp(-pow((x - 85 - offset), 2) / 80);
    s += (onde_P + onde_Q + onde_R + onde_S + onde_T);
    
    offset += 100;

    // Sortir de la boucle si nécessaire
    if (offset > 1000) {
      break; // Sortir de la boucle infinie lorsque offset dépasse 900
    }
  }

  // Additionner les composantes des signaux
  return (s * 6) + TFT_HEIGHT / 2 + 20;
}


float calculateCombinedSignal2(int x) {
  float s2 = 0;
  int offset = 1;

  while (true) { // Boucle infinie
  float y1 = -(3.5/ 0.25) * exp(-pow((x - 15-offset), 2) / pow(4, 2));
  float y2 = (7) * exp(-pow((x - 20-offset), 2) / pow(8, 2));
  float y3 = -(2) * exp(-pow((x -20.2-offset), 2) / pow(6, 2));
  s2+=y1+y2+y3;
   offset += 120;

    // Sortir de la boucle si nécessaire
    if (offset > 1000) {
      break; // Sortir de la boucle infinie lorsque offset dépasse 900
    }
  }
 return 0.4 *s2* 10 + TFT_HEIGHT / 2; // Scale and shift the result for display
}
float calculateCombinedSignal3(int x) {
  float s3 = 0;
  int offset = 1;

  while (true) { // Boucle infinie
  float y1 = -(0.4 / 2.5) * exp(-pow((x - 12-offset), 2) / pow(6, 2));
  float y2 = -(0.5 / 5) * exp(-pow((x - 25.5-offset), 2) / pow(3, 2));
  float y3 = -(0.4 / 5) * exp(-pow((x - 35-offset), 2) / pow(2, 2));
  float y4 = (0.7 / 5) * exp(-pow((x - 40-offset), 2) / pow(2, 2));
  float y5 = -(0.6 / 9) * exp(-pow((x - 50-offset), 2) / 15);
  float y6 = -(0.7 / 3.0) * exp(-pow((x - 60-offset), 2) / pow(12, 2));
  s3+=y1 - y2 + y3 + y4 + y5 + y6;
  offset += 90;

    // Sortir de la boucle si nécessaire
    if (offset > 1000) {
      break; // Sortir de la boucle infinie lorsque offset dépasse 900
    }
  }

  return (s3) * 15 + TFT_HEIGHT / 2;
}

float calculateCombinedSignal4(int x) {
  float sum_y34 = 0;
  for (int n = 1; n <= 400; n += 15) {
    float y3 = -(3.0 / 0.2) * exp(-pow((x - (5 + n)), 2) / pow(2, 2));
    float y4 = (0.8) * exp(-pow((x - (8 + n) ), 2) / pow(9,2));
    sum_y34 += y3 + y4;
  }
  return (sum_y34 * 5) + TFT_HEIGHT / 2;
}