#include "EEPROM.h"

// Definição dos pinos dos LEDs
const int ledAmarelo = 9;
const int ledAzul = 10;
const int ledVerde = 11;
const int ledVermelho = 12;

// Definição dos pinos dos botões
const int botaoAmarelo = 2;
const int botaoAzul = 3;
const int botaoVerde = 4;
const int botaoVermelho = 5;

// Definição do pino do buzzer
const int buzzer = 8;

// Notas musicais correspondentes aos LEDs
const int notaAmarelo = 262; // Dó
const int notaAzul = 294; // Ré
const int notaVerde = 330; // Mi
const int notaVermelho = 349; // Fá

// Variável para definir o tempo que o LED fica aceso
int tempoLedAceso = 300; // em milissegundos

// Endereço na EEPROM para armazenar o recorde
const int enderecoRecorde = 0;

// Variável para armazenar o recorde
int recorde = 0;

// Array para armazenar a sequência gerada pelo jogo
int sequencia[100];
int tamanhoSequencia = 0;

// Função setup é executada uma vez quando o Arduino é ligado
void setup() {
  // Configuração dos pinos dos LEDs como saída
  pinMode(ledAmarelo, OUTPUT);
  pinMode(ledAzul, OUTPUT);
  pinMode(ledVerde, OUTPUT);
  pinMode(ledVermelho, OUTPUT);

  // Configuração dos pinos dos botões como entrada pull-up
  pinMode(botaoAmarelo, INPUT_PULLUP);
  pinMode(botaoAzul, INPUT_PULLUP);
  pinMode(botaoVerde, INPUT_PULLUP);
  pinMode(botaoVermelho, INPUT_PULLUP);

  // Configuração do pino do buzzer como saída
  pinMode(buzzer, OUTPUT);

  // Inicialização da comunicação serial para debug
  Serial.begin(9600);
  
  // Inicializa o gerador de números aleatórios
  randomSeed(analogRead(0));

  // Carrega o recorde da EEPROM
  EEPROM.get(enderecoRecorde, recorde);

  // Exibe o recorde no monitor serial
  Serial.print("Recorde atual: ");
  Serial.println(recorde);

  // Mensagem inicial no monitor serial
  Serial.println("Pressione qualquer botão para iniciar");

  // Espera pelo jogador para iniciar a partida
  esperarNovoJogo();
}

// Função loop é executada continuamente
void loop() {
  // Mostra a sequência ao jogador
  mostrarSequencia();

  // Verifica a entrada do jogador
  if (!verificarEntradaJogador()) {
    Serial.println("Game Over!");
    tocarMusicaDerrota();

    // Atualiza o recorde se o jogador tiver atingido um novo recorde
    if (tamanhoSequencia - 1 > recorde) {
      recorde = tamanhoSequencia - 1;
      EEPROM.put(enderecoRecorde, recorde);
      Serial.print("Novo recorde: ");
      Serial.println(recorde);
    }

    Serial.println("Pressione qualquer botão para iniciar");
    esperarNovoJogo();
  } else {
    Serial.println("Correto! Próxima rodada.");
    delay(1000);
    gerarSequencia();
  }
}

// Função para gerar uma nova sequência
void gerarSequencia() {
  sequencia[tamanhoSequencia] = random(4); // Gera um número aleatório entre 0 e 3
  tamanhoSequencia++;
  Serial.print("Nível: ");
  Serial.println(tamanhoSequencia); // Imprime o nível atual no monitor serial
}

// Função para mostrar a sequência ao jogador
void mostrarSequencia() {
  for (int i = 0; i < tamanhoSequencia; i++) {
    acenderLed(sequencia[i]);
    delay(500); // Aguarda meio segundo entre cada LED
    apagarLeds();
    delay(500); // Pausa entre cada LED na sequência
  }
}

// Função para acender o LED correspondente e tocar a nota musical
void acenderLed(int led) {
  switch (led) {
    case 0:
      digitalWrite(ledAmarelo, HIGH);
      tone(buzzer, notaAmarelo);
      break;
    case 1:
      digitalWrite(ledAzul, HIGH);
      tone(buzzer, notaAzul);
      break;
    case 2:
      digitalWrite(ledVerde, HIGH);
      tone(buzzer, notaVerde);
      break;
    case 3:
      digitalWrite(ledVermelho, HIGH);
      tone(buzzer, notaVermelho);
      break;
  }
}

// Função para apagar todos os LEDs e parar o som
void apagarLeds() {
  digitalWrite(ledAmarelo, LOW);
  digitalWrite(ledAzul, LOW);
  digitalWrite(ledVerde, LOW);
  digitalWrite(ledVermelho, LOW);
  noTone(buzzer);
}

// Função para verificar a entrada do jogador
bool verificarEntradaJogador() {
  for (int i = 0; i < tamanhoSequencia; i++) {
    int botaoPressionado = esperarBotaoPressionado();
    if (botaoPressionado != sequencia[i]) {
      return false; // Entrada incorreta
    }
  }
  return true; // Entrada correta
}

// Função para esperar até que um botão seja pressionado
int esperarBotaoPressionado() {
  while (true) {
    if (digitalRead(botaoAmarelo) == LOW) {
      digitalWrite(ledAmarelo, HIGH); // Acende o LED correspondente
      tone(buzzer, notaAmarelo); // Toca a nota correspondente
      delay(tempoLedAceso); // Mantém o LED aceso pelo tempo definido
      digitalWrite(ledAmarelo, LOW); // Apaga o LED
      noTone(buzzer); // Para a nota
      while (digitalRead(botaoAmarelo) == LOW); // Espera até o botão ser solto
      return 0;
    }
    if (digitalRead(botaoAzul) == LOW) {
      digitalWrite(ledAzul, HIGH); // Acende o LED correspondente
      tone(buzzer, notaAzul); // Toca a nota correspondente
      delay(tempoLedAceso); // Mantém o LED aceso pelo tempo definido
      digitalWrite(ledAzul, LOW); // Apaga o LED
      noTone(buzzer); // Para a nota
      while (digitalRead(botaoAzul) == LOW); // Espera até o botão ser solto
      return 1;
    }
    if (digitalRead(botaoVerde) == LOW) {
      digitalWrite(ledVerde, HIGH); // Acende o LED correspondente
      tone(buzzer, notaVerde); // Toca a nota correspondente
      delay(tempoLedAceso); // Mantém o LED aceso pelo tempo definido
      digitalWrite(ledVerde, LOW); // Apaga o LED
      noTone(buzzer); // Para a nota
      while (digitalRead(botaoVerde) == LOW); // Espera até o botão ser solto
      return 2;
    }
    if (digitalRead(botaoVermelho) == LOW) {
      digitalWrite(ledVermelho, HIGH); // Acende o LED correspondente
      tone(buzzer, notaVermelho); // Toca a nota correspondente
      delay(tempoLedAceso); // Mantém o LED aceso pelo tempo definido
      digitalWrite(ledVermelho, LOW); // Apaga o LED
      noTone(buzzer); // Para a nota
      while (digitalRead(botaoVermelho) == LOW); // Espera até o botão ser solto
      return 3;
    }
  }
}

// Função para tocar a música de abertura com animação de LEDs
void tocarMusicaAbertura() {
  acenderLed(0);
  delay(300);
  apagarLeds();
  noTone(buzzer);
  delay(100);
  acenderLed(1);
  delay(300);
  apagarLeds();
  noTone(buzzer);
  delay(100);
  acenderLed(2);
  delay(300);
  apagarLeds();
  noTone(buzzer);
  delay(100);
  acenderLed(3);
  delay(300);
  apagarLeds();
  noTone(buzzer);
  delay(1000); // Espera um segundo antes de iniciar a partida
}

// Função para tocar a música de derrota com animação de LEDs
void tocarMusicaDerrota() {
  int notas[] = {330, 294, 262, 196, 150, 130, 110, 98}; // Sequência das notas da derrota
  int duracoes[] = {150, 150, 150, 150, 150, 150, 150, 600}; // Duração de cada nota

  for (int i = 0; i < 8; i++) {
    tone(buzzer, notas[i]);
    digitalWrite(ledVermelho, HIGH);
    digitalWrite(ledAmarelo, HIGH);
    digitalWrite(ledAzul, HIGH);
    digitalWrite(ledVerde, HIGH);
    delay(duracoes[i]);
    apagarLeds();
    noTone(buzzer);
    delay(100); // Pequena pausa entre as notas
  }
  delay(1000); // Espera um segundo antes de permitir iniciar uma nova partida
}

// Função para esperar até que um botão seja pressionado para iniciar um novo jogo
void esperarNovoJogo() {
  Serial.println("Pressione qualquer botão para iniciar");
  while (true) {
    if (digitalRead(botaoAmarelo) == LOW || digitalRead(botaoAzul) == LOW || digitalRead(botaoVerde) == LOW || digitalRead(botaoVermelho) == LOW) {
      while (digitalRead(botaoAmarelo) == LOW || digitalRead(botaoAzul) == LOW || digitalRead(botaoVerde) == LOW || digitalRead(botaoVermelho) == LOW);
      tamanhoSequencia = 0; // Reinicia o tamanho da sequência
      gerarSequencia(); // Gera uma nova sequência
      tocarMusicaAbertura(); // Toca a música de abertura com animação de LEDs
      break;
    }
  }
}