// Definir el pin donde comienzan los LED y el número total de LED
const int primerPin = 2;
const int numeroDeLED = 21;

// Definir el pin donde comienzan los botones y el número total de botones
const int primerBotonPin = 23;
const int numeroDeBotones = 21;
// Definir los pines de los botones y el número total de botones
const int pinesBotones[] = {23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43};

// - 1 botón pulsador inicial/reset denominado “BR”
// Definir el pin del botón
const int pinBotonBR = 53;

//-	1 botón pulsador denominado “BI” 
// Definir el pin del botón
const int pinBotonBI = 52;

// Definir los pines de los LEDs
const int pinLEDFV = A0;
const int pinLEDFA = A1;
const int pinLEDFR = A2;
const int pinLEDFI = A3;
const int pinGanchoGI = A4;

// Declarar la matriz
int SEC4[5][4] = {
  {3, 20, 8, 11},
  {10, 13, 15, 4},
  {21, 13, 9, 6},
  {13, 8, 6, 11},
  {17, 10, 6, 8}
};

int sec1[4] = {0,0,0,0};
int sec1_verificar[4] = {0,0,0,0};
bool todosSonUno = true;


int SEC5[5][5] = {
  {7, 2, 16, 12, 1},
  {20, 3, 17, 14, 2},
  {15, 18, 3, 20, 10},
  {13, 9, 21, 4, 16},
  {4, 9, 15, 12, 1}
};

int sec2[5] = {0,0,0,0,0};
int sec2_verificar[5] = {0,0,0,0,0};
//bool todosSonUno = true;

int SEC6[5][6] = {
  {18, 6, 9, 16, 14, 19},
  {1, 5, 18, 8, 6, 16},
  {12, 3, 17, 6, 14, 1}, 
  {2, 17, 5, 4, 15, 13},
  {14, 3, 11, 15, 7, 19}
}; 

int sec3[6] = {0,0,0,0,0,0};
int sec3_verificar[6] = {0,0,0,0,0,0};

int retardo=0;
int contador_sec1 = 0;
int contador_sec2 = 0;
int contador_sec3 = 0;
int secuencia1 = 0;
int secuencia2 = 0;
int secuencia3 = 0;
bool secuencia1Activa = false;
bool secuencia2Activa = false;
bool secuencia3Activa = false;
bool secuencia4Activa = false;
int filaRandom1 = 0;
int filaRandom2 = 0;
int filaRandom3 = 0; 
int ciclo_final = 0;

void setup() {
  // Inicializar los pines de los LED como salida
  for (int pin = primerPin; pin < primerPin + numeroDeLED; pin++) {
    pinMode(pin, OUTPUT);
    }

  // Apagar los LED de forma secuencial
  for (int pin = primerPin; pin < primerPin + numeroDeLED; pin++) {
    digitalWrite(pin, HIGH);  // Apagar el LED actual
    }

  // Inicializar los pines de los botones como entrada con pull-up
  for (int botonPin = primerBotonPin; botonPin < primerBotonPin + numeroDeBotones; botonPin++) {
    pinMode(botonPin, INPUT_PULLUP);
    }

  // Inicializar el pin del botón como entrada con pull-up
  pinMode(pinBotonBR, INPUT_PULLUP);
  pinMode(pinBotonBI, INPUT_PULLUP);

    // Inicializar los pines de los LEDs como salida
  pinMode(pinLEDFV, OUTPUT);
  pinMode(pinLEDFA, OUTPUT);
  pinMode(pinLEDFR, OUTPUT);
  pinMode(pinLEDFI, OUTPUT);
  pinMode(pinGanchoGI, OUTPUT);
  digitalWrite(pinLEDFV, HIGH);
  digitalWrite(pinLEDFA, HIGH);
  //digitalWrite(pinLEDFR, HIGH);
  digitalWrite(pinLEDFI, HIGH);
  digitalWrite(pinGanchoGI, HIGH);

  Serial.begin(9600);
  //Unicamente dejando encendido foco piloto “FR” indicando que el juego esta encendido.
   digitalWrite(pinLEDFR, LOW);
  }

void loop() {
  inicioSecuencia();
}



// Funcion de inicio de secuencia
void inicioSecuencia(){
  // Leer el estado del botón
  int estadoBotonBR = digitalRead(pinBotonBR);
   // Verificar si el botón está presionado
   //El jugador deberá presionar “BR” para iniciar o reiniciar el juego
  if (estadoBotonBR == LOW) {
    // Generar un índice de fila aleatorio
    filaRandom1 = random(1,5); // Número aleatorio entre 0 y 4 (5 filas)
    //filaRandom1 = 4;
    filaRandom2 = filaRandom1;
    filaRandom3 = filaRandom1;
    Serial.println(filaRandom1);
    Serial.println("Inicia secuencia1 de leds");
    digitalWrite(pinLEDFA, LOW);
    digitalWrite(pinLEDFR, HIGH);
    // Ejecutar la secuencia 1 si está activa
    secuencia1Activa = true;
    secuencia2Activa = false;
    secuencia3Activa = false;
    delay(200);
    }


  while (secuencia1Activa == true) {
    // Coloca aquí el código de la secuencia 1
    // Encender los LEDs según la fila seleccionada
    if(secuencia1 ==0){
        for (int i = 0; i < 4; i++) {
          int pinLED = SEC4[i]; // Seleccionar el LED correspondiente al índice
          int valorLED = SEC4[filaRandom1-1][i]; // Obtener el valor de la matriz para el LED correspondiente
          retardo = 1000; // retardo secuencia 1
          encenderLED(valorLED+1, retardo);
          if(i==3){
            Serial.println("Termina secuencia1 de leds");
          }
        }
        secuencia1 = 1;
      }
    
    // Leer el estado de cada botón
    for (int i = 0; i <= numeroDeBotones; i++) {
    int estadoBoton = digitalRead(pinesBotones[i]);
      
    // Verificar si el botón se ha pulsado
      if (estadoBoton == LOW) {
        //Serial.println(i);
        delay(250); // Pequeño retardo para evitar rebotes en el botón
        Serial.print("Boton pulsado: ");
        Serial.println(i+1); // Sumamos 1 para que los botones se numeren desde 1 en lugar de 0
        Serial.print("array original1: ");
        Serial.println(SEC4[filaRandom1-1][contador_sec1]);
        sec1[contador_sec1]= i+1;

        contador_sec1++ ;
        if (SEC4[filaRandom1-1][contador_sec1-1] == sec1[contador_sec1-1]) {
          sec1_verificar[contador_sec1-1] = 1;
          Serial.print("array de verificacion1: ");
          Serial.println(sec1_verificar[contador_sec1-1]);
          int pin_encendido = SEC4[filaRandom1-1][contador_sec1-1]+1;
          digitalWrite(pin_encendido , LOW);
          //Serial.println(pin_encendido);
          }
        else{
          sec1_verificar[contador_sec1-1] = 0;
          Serial.print("array de verificacion: ");
          Serial.println(sec1_verificar[contador_sec1-1]);
          //Serial.println("No todos los elementos de sec1 son 1.");
          secuencia1Activa = false; // Establecer la condición a true para salir del bucle while
          contador_sec1=4 ;
          todosSonUno = true;
        }            
      }

      if(contador_sec1 == 4){
          todosSonUno = true;
          for (int j = 0; j < 4; j++) {
            if (sec1_verificar[j] != 1) {
            todosSonUno = false;
            break; // Salir del bucle si se encuentra un elemento distinto de 1
              }
            }
            // Imprimir el resultado
            if (todosSonUno == true) {
            Serial.println("Todos los elementos de sec1 son 1.");
            delay(1000);
            // Apagar los LED de forma secuencial
            for (int pin = primerPin; pin < primerPin + numeroDeLED; pin++) {
              digitalWrite(pin, HIGH);  // Apagar el LED actual
                }
            Serial.println("Paso a secuencia 2");
            secuencia1Activa = false; // Establecer la condición a true para salir del bucle while
            secuencia2Activa = true;
            delay(200);
            Serial.println(filaRandom1);
            Serial.println("Inicia secuencia2 de leds");
            } else {
              Serial.println("No todos los elementos de sec1 son 1.");
              for (int pin = primerPin; pin < primerPin + numeroDeLED; pin++) {
              digitalWrite(pin, HIGH);  // Apagar el LED actual
                }
              digitalWrite(pinLEDFA, HIGH);
              digitalWrite(pinLEDFR, LOW);
              Serial.println("Reinicio de secuencia 1");
              secuencia1Activa = false; // Establecer la condición a true para salir del bucle while
              contador_sec1=0 ;
              todosSonUno = true;
              secuencia1 = 0;
              }
              todosSonUno = false;
              contador_sec1 = 0;
        }
    }
  } // fin de la secuencia 1  ********************************************************************************* 


  // Ejecutar la secuencia 2 si está activa
  while (secuencia2Activa == true) {
    // Coloca aquí el código de la secuencia 2
        // Encender los LEDs según la fila seleccionada
        //Serial.println("Termdasdasdina secuencia2 de leds");
    if(secuencia2 == 0){
        for (int i = 0; i < 5; i++) {
          int pinLED = SEC5[i]; // Seleccionar el LED correspondiente al índice
          int valorLED = SEC5[filaRandom2-1][i]; // Obtener el valor de la matriz para el LED correspondiente
          retardo = 1000; // retardo secuencia 2
          encenderLED(valorLED+1, retardo);
          if(i==4){
            Serial.println("Termina secuencia2 de leds");
          }
        }
        secuencia2 = 1;
      }
    
    // Leer el estado de cada botón
    for (int ii = 0; ii <= numeroDeBotones; ii++) {
    int estadoBoton2 = digitalRead(pinesBotones[ii]);
    // Verificar si el botón se ha pulsado
      if (estadoBoton2 == LOW) {
        delay(250); // Pequeño retardo para evitar rebotes en el botón
        if(ii<21){
          Serial.println(ii);
          Serial.print("Boton pulsado: ");
          Serial.println(ii+1); // Sumamos 1 para que los botones se numeren desde 1 en lugar de 0
          Serial.print("array original2: ");
          Serial.println(SEC5[filaRandom2-1][contador_sec2]);
          sec2[contador_sec2]= ii+1;

          contador_sec2++ ;
          if (SEC5[filaRandom2-1][contador_sec2-1] == sec2[contador_sec2-1]) {
            sec2_verificar[contador_sec2-1] = 1;
            Serial.print("array de verificacion2: ");
            Serial.println(sec2_verificar[contador_sec2-1]);
            int pin_encendido2 = SEC5[filaRandom2-1][contador_sec2-1]+1;
            digitalWrite(pin_encendido2 , LOW);
            //Serial.println(pin_encendido);
            }
          else{
            sec2_verificar[contador_sec2-1] = 0;
            Serial.print("array de verificacion2: ");
            Serial.println(sec2_verificar[contador_sec2-1]);
            //Serial.println("No todos los elementos de sec1 son 1.");
            secuencia1Activa = false; // Establecer la condición a true para salir del bucle while
            contador_sec2=5 ;
            todosSonUno = true;
          }  
        }
      }

      if(contador_sec2 == 5){
          todosSonUno = true;
          for (int j = 0; j < 5; j++) {
            if (sec2_verificar[j] != 1) {
            todosSonUno = false;
            break; // Salir del bucle si se encuentra un elemento distinto de 1
              }
            }
            // Imprimir el resultado
            if (todosSonUno == true) {
            Serial.println("Todos los elementos de sec2 son 1.");
            delay(1000);
            // Apagar los LED de forma secuencial
            for (int pin = primerPin; pin < primerPin + numeroDeLED; pin++) {
              digitalWrite(pin, HIGH);  // Apagar el LED actual
                }
            Serial.println("Paso a secuencia 3");
            secuencia1Activa = false; // Establecer la condición a true para salir del bucle while
            secuencia2Activa = false;
            secuencia3Activa = true;
            delay(200);
            Serial.println(filaRandom2);
            Serial.println("Inicia secuencia3 de leds");
            } else {
              Serial.println("No todos los elementos de sec2 son 1.");
              for (int pin = primerPin; pin < primerPin + numeroDeLED; pin++) {
              digitalWrite(pin, HIGH);  // Apagar el LED actual
                }
              digitalWrite(pinLEDFA, HIGH);
              digitalWrite(pinLEDFR, LOW);
              Serial.println("Reinicio de secuencia 1");
              secuencia1Activa = false; // Establecer la condición a true para salir del bucle while
              secuencia2Activa = false;
              contador_sec2=0 ;
              todosSonUno = true;
              secuencia2 = 0;
              }
              todosSonUno = false;
              contador_sec2 = 0;
        }
    }  
  } // fin de la secuencia 2  ********************************************************************************* 


  // Ejecutar la secuencia 3 si está activa
  while (secuencia3Activa== true) {
  // Coloca aquí el código de la secuencia 3
    // Encender los LEDs según la fila seleccionada
    if(secuencia3 == 0){
        for (int i = 0; i < 6; i++) {
          int pinLED = SEC6[i]; // Seleccionar el LED correspondiente al índice
          int valorLED = SEC6[filaRandom3-1][i]; // Obtener el valor de la matriz para el LED correspondiente
          retardo = 1000; // retardo secuencia 3
          encenderLED(valorLED+1, retardo);
          if(i==5){
            Serial.println("Termina secuencia3 de leds");
          }
        }
        secuencia3 = 1;
      }
    
    // Leer el estado de cada botón
    for (int k = 0; k <= numeroDeBotones; k++) {
    int estadoBoton3 = digitalRead(pinesBotones[k]);
    // Verificar si el botón se ha pulsado
      if (estadoBoton3 == LOW) {
        delay(250); // Pequeño retardo para evitar rebotes en el botón
        if(k<21){
        Serial.print("Boton pulsado: ");
        Serial.println(k+1); // Sumamos 1 para que los botones se numeren desde 1 en lugar de 0
        Serial.print("array original3: ");
        Serial.println(SEC6[filaRandom3-1][contador_sec3]);
        sec3[contador_sec3]= k+1;
        contador_sec3++ ;
        if (SEC6[filaRandom3-1][contador_sec3-1] == sec3[contador_sec3-1]) {
          sec3_verificar[contador_sec3-1] = 1;
          Serial.print("array de verificacion3: ");
          Serial.println(sec3_verificar[contador_sec3-1]);
          int pin_encendido = SEC6[filaRandom3-1][contador_sec3-1]+1;
          digitalWrite(pin_encendido , LOW);
          //Serial.println(pin_encendido);
          }
        else{
          sec3_verificar[contador_sec3-1] = 0;
          Serial.print("array de verificacion3: ");
          Serial.println(sec3_verificar[contador_sec3-1]);
          //Serial.println("No todos los elementos de sec1 son 1.");
          secuencia1Activa = false; // Establecer la condición a true para salir del bucle while
          secuencia2Activa = false; // Establecer la condición a true para salir del bucle while
          contador_sec3=6 ;
          todosSonUno = true;
         } 
        }           
      }

      if(contador_sec3 == 6){
          todosSonUno = true;
          for (int j = 0; j < 6; j++) {
            if (sec3_verificar[j] != 1) {
            todosSonUno = false;
            break; // Salir del bucle si se encuentra un elemento distinto de 1
              }
            }
            // Imprimir el resultado
            if (todosSonUno == true) {
            Serial.println("Todos los elementos de sec3 son 1.");
            delay(1000);
            // Apagar los LED de forma secuencial
            for (int pin = primerPin; pin < primerPin + numeroDeLED; pin++) {
              digitalWrite(pin, HIGH);  // Apagar el LED actual
                }
            Serial.println("Paso a secuencia final");
            secuencia1Activa = false; // Establecer la condición a true para salir del bucle while
            secuencia2Activa = false;
            secuencia3Activa = false;
            secuencia4Activa = true;
            delay(200);
            Serial.println("Inicia secuencia final");
            } else {
              Serial.println("No todos los elementos de sec3 son 1.");
              for (int pin = primerPin; pin < primerPin + numeroDeLED; pin++) {
              digitalWrite(pin, HIGH);  // Apagar el LED actual
                }
              digitalWrite(pinLEDFA, HIGH);
              digitalWrite(pinLEDFR, LOW);
              Serial.println("Reinicio de secuencia 1");
              secuencia1Activa = false; // Establecer la condición a true para salir del bucle while
              secuencia2Activa = false;
              secuencia3Activa = false;
              secuencia4Activa = false;
              contador_sec3=0 ;
              todosSonUno = true;
              secuencia3 = 0;
              }
              todosSonUno = false;
              contador_sec3 = 0;
        }
    }  
  } // fin de la secuencia 3  *************************************

  // Ejecutar la secuencia 4 si está activa
   if(secuencia4Activa== true) {
    digitalWrite(pinLEDFA, HIGH);
    digitalWrite(pinLEDFR, HIGH);
    digitalWrite(pinLEDFI, LOW);
    digitalWrite(pinLEDFV, LOW);
    digitalWrite(pinGanchoGI, LOW);
    delay(3000);
    Serial.println("Se apaga gancho GI");
    digitalWrite(pinGanchoGI, HIGH);
    delay(7000);
    digitalWrite(pinLEDFV, HIGH);
    Serial.println("Se apaga Led FV");
    while(ciclo_final == 0){
      delay(50);
      int estadoBotonBI = digitalRead(pinBotonBI);
      if(estadoBotonBI == LOW){
        digitalWrite(pinGanchoGI, LOW); 
        delay(200);
          }
      else{
        digitalWrite(pinGanchoGI, HIGH);
          }
        }

  }

}

// Función para encender un LED específico
void encenderLED(int pin, int tiempo) {
  digitalWrite(pin, LOW);
  delay(tiempo);
  digitalWrite(pin, HIGH);

}