//Autor: Pedro Guilherme Torres Barroso
#include <LiquidCrystal.h>
#include <ctype.h> // para a função isprint()


// Definir os pinos do LCD
const int rs = 12, rw = 13, enable = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, rw, enable, d4, d5, d6, d7);

// Definir os pinos dos botões
const int btnUp = 6;
const int btnDown = 7;
const int btnSelect = 8;

const int ledVerde = 9;     // LED verde conectado ao pino digital 9
const int ledAmarelo = 10;  // LED amarelo conectado ao pino digital 10
const int ledVermelho = 11; // LED vermelho conectado ao pino digital 11

// Variáveis para armazenar o saldo e o menu atual
int menuAtual = 0;

// Estrutura para armazenar os usuários
struct Usuario {
  char nome[20];
  char senha[10];
  float saldo;
};

// Vetor para armazenar os usuários cadastrados
Usuario usuarios[10];
int numUsuarios = 0;

// Função para exibir o menu principal
void exibirMenu() {
  lcd.clear();
  lcd.print("Que desejas efetuar?");
  lcd.setCursor(0, 1);
}

// Função para limpar caracteres não imprimíveis
void limparCaracteresNaoImprimiveis(char* str) {
  int i = 0, j = 0;
  while (str[i]) {
    // Se o caractere for imprimível, incluindo espaço, ele é mantido
    if (isprint((unsigned char)str[i]) || str[i] == ' ') {
      str[j++] = str[i];
    }
    i++;
  }
  str[j] = '\0'; // Certifique-se de terminar a string modificada com um caractere null
}

// Inicializar alguns usuários de teste
void inicializarUsuarios() {
  strcpy(usuarios[0].nome, "usuario1");
  strcpy(usuarios[0].senha, "senha1");
  usuarios[0].saldo = 0.0;

  strcpy(usuarios[1].nome, "usuario2");
  strcpy(usuarios[1].senha, "senha2");
  usuarios[1].saldo = 0.0;

  numUsuarios = 0;
}

void limparBufferSerial() {
  while (Serial.available() > 0) {
    Serial.read(); // Ler e descartar caracteres residuais no buffer
  }
}


void cadastrarUsuario() {
  limparBufferSerial(); // Limpar o buffer serial antes de solicitar entrada
  lcd.clear();
  lcd.print("Nome:");
  delay(2000);

  char nome[20];
  memset(nome, 0, sizeof(nome)); // Limpar o buffer de entrada

  while (Serial.available() == 0) {
    ; // Fica no loop até que os dados estejam disponíveis para leitura
  }
  Serial.readBytesUntil('\n', nome, sizeof(nome) - 1); // Ler a entrada até o próximo caractere de nova linha
  limparCaracteresNaoImprimiveis(nome); // Limpar caracteres não imprimíveis

  lcd.clear();
  lcd.print("Senha:");
  delay(2000);

  char senha[10];
  memset(senha, 0, sizeof(senha)); // Limpar o buffer de entrada

  while (Serial.available() == 0) {
    ; // Fica no loop até que os dados estejam disponíveis para leitura
  }
  Serial.readBytesUntil('\n', senha, sizeof(senha) - 1); // Ler a entrada até o próximo caractere de nova linha
  limparCaracteresNaoImprimiveis(senha); // Limpar caracteres não imprimíveis

  // Verificar se o usuário já está cadastrado
  for (int i = 0; i < numUsuarios; i++) {
    if (strcmp(usuarios[i].nome, nome) == 0 && strcmp(usuarios[i].senha, senha) == 0) {
      lcd.clear();
      lcd.print("Usuario e senha");
      lcd.setCursor(0, 1);
      lcd.print("ja cadastrados!");
      digitalWrite(ledVermelho, HIGH); // Acender LED vermelho (erro)
      delay(2000);
      digitalWrite(ledVermelho, LOW);  // Apagar LED vermelho
      return;
    }
  }

  // Se o usuário não estiver cadastrado, prosseguir com o cadastro
  strcpy(usuarios[numUsuarios].nome, nome);
  strcpy(usuarios[numUsuarios].senha, senha);
  usuarios[numUsuarios].saldo = 0.0;
  numUsuarios++;

  Serial.print("Usuario cadastrado: ");
  Serial.println(usuarios[numUsuarios - 1].nome); // Imprimir o usuário cadastrado

  lcd.clear();
  lcd.print("Cadastro OK!");
  digitalWrite(ledVerde, HIGH); // Acender LED verde (sucesso)
  delay(2000);
  digitalWrite(ledVerde, LOW);  // Apagar LED verde

}

// Função para autenticar o usuário
int autenticarUsuario() {
  limparBufferSerial(); // Limpar o buffer serial antes de solicitar entrada
  lcd.clear();
  lcd.print("Digite o nome:");
  delay(2000);

  char nome[20];
  memset(nome, 0, sizeof(nome)); // Limpar o buffer de entrada

  while (Serial.available() == 0) {
    Serial.print("Lendo entrada..."); // Imprimir mensagem enquanto aguarda entrada
  }
  Serial.readBytesUntil('\n', nome, sizeof(nome) - 1); // Ler a entrada até o próximo caractere de nova linha
  limparCaracteresNaoImprimiveis(nome); // Limpar caracteres não imprimíveis
  Serial.read(); // Limpar o buffer serial
  Serial.print("Nome lido: ");
  Serial.println(nome);

  lcd.clear();
  lcd.print("Digite a senha:");
  delay(2000);

  char senha[10];
  memset(senha, 0, sizeof(senha)); // Limpar o buffer de entrada

  while (Serial.available() == 0) {
    Serial.print("Lendo entrada..."); // Imprimir mensagem enquanto aguarda entrada
  }
  Serial.readBytesUntil('\n', senha, sizeof(senha) - 1); // Ler a entrada até o próximo caractere de nova linha
  limparCaracteresNaoImprimiveis(senha); // Limpar caracteres não imprimíveis
  Serial.read(); // Limpar o buffer serial
  Serial.print("Senha lida: ");
  Serial.println(senha);

  // Procurar o usuário
  for (int i = 0; i < numUsuarios; i++) {
    char nomeMaiusculo[20], senhaMaiusculo[10];
    strcpy(nomeMaiusculo, usuarios[i].nome);
    strcpy(senhaMaiusculo, usuarios[i].senha);

    // Converter para maiúsculo antes de comparar
    for (int j = 0; nomeMaiusculo[j]; j++) {
      nomeMaiusculo[j] = toupper(nomeMaiusculo[j]);
    }
    for (int j = 0; senhaMaiusculo[j]; j++) {
      senhaMaiusculo[j] = toupper(senhaMaiusculo[j]);
    }

    if (strcmp(nomeMaiusculo, strupr(nome)) == 0 && strcmp(senhaMaiusculo, strupr(senha)) == 0) {
      return i; // Retorna o índice do usuário autenticado
    }
  }

  // Se o usuário não for encontrado, retorna -1
  lcd.clear();
  lcd.print("Usuario nao encontrado!");
  digitalWrite(ledVermelho, HIGH); // Acender LED vermelho (erro)
  delay(2000);
  digitalWrite(ledVermelho, LOW);  // Apagar LED vermelho
  return -1;
}

// Função para realizar um depósito
void deposito() {
  int usuarioAutenticado = autenticarUsuario();
  if (usuarioAutenticado == -1) {
    lcd.clear();
    lcd.print("Usuario nao encontrado!");
    digitalWrite(ledVermelho, HIGH); // Acender LED vermelho (erro)
    delay(2000);
    digitalWrite(ledVermelho, LOW);  // Apagar LED vermelho
    return;
  }

  lcd.clear();
  lcd.print("Digite o valor:");

  float valor = 0.0;
  bool valorValido = false;
  char inputBuffer[10]; // Buffer para armazenar a entrada do usuário
  memset(inputBuffer, 0, sizeof(inputBuffer)); // Limpar o buffer de entrada

  while (!valorValido) {
    while (Serial.available() == 0) {
      ; // Fica no loop até que os dados estejam disponíveis para leitura
    }
    Serial.readBytesUntil('\n', inputBuffer, sizeof(inputBuffer) - 1); // Ler a entrada até o próximo caractere de nova linha
    limparCaracteresNaoImprimiveis(inputBuffer); // Limpar caracteres não imprimíveis
    valor = atof(inputBuffer); // Converter a string lida para float

    if (valor > 0) {
      usuarios[usuarioAutenticado].saldo += valor;
      lcd.clear();
      lcd.print("Deposito OK!");
      digitalWrite(ledVerde, HIGH); // Acender LED verde (sucesso)
      delay(2000);
      digitalWrite(ledVerde, LOW);  // Apagar LED verde
      valorValido = true;
    } else {
      lcd.clear();
      lcd.print("Valor invalido!");
      digitalWrite(ledAmarelo, HIGH); // Acender LED amarelo (alerta)
      delay(2000);
      digitalWrite(ledAmarelo, LOW);  // Apagar LED amarelo
    }
  }
}

// Função para realizar um saque
void saque() {
  int usuarioAutenticado = autenticarUsuario();
  if (usuarioAutenticado == -1) {
    lcd.clear();
    lcd.print("Usuario nao encontrado!");
    digitalWrite(ledVermelho, HIGH); // Acender LED vermelho (erro)
    delay(2000);
    digitalWrite(ledVermelho, LOW);  // Apagar LED vermelho
    return;
  }

  lcd.clear();
  lcd.print("Digite o valor:");

  float valor = 0.0;
  bool valorValido = false;
  char inputBuffer[10]; // Buffer para armazenar a entrada do usuário
  memset(inputBuffer, 0, sizeof(inputBuffer)); // Limpar o buffer de entrada

  while (!valorValido) {
    while (Serial.available() == 0) {
      ; // Fica no loop até que os dados estejam disponíveis para leitura
    }
    Serial.readBytesUntil('\n', inputBuffer, sizeof(inputBuffer) - 1); // Ler a entrada até o próximo caractere de nova linha
    limparCaracteresNaoImprimiveis(inputBuffer); // Limpar caracteres não imprimíveis
    valor = atof(inputBuffer); // Converter a string lida para float

    if (valor > 0 && valor <= usuarios[usuarioAutenticado].saldo) {
      usuarios[usuarioAutenticado].saldo -= valor;
      lcd.clear();
      lcd.print("Saque OK!");
      digitalWrite(ledVerde, HIGH); // Acender LED verde (sucesso)
      delay(2000);
      digitalWrite(ledVerde, LOW);  // Apagar LED verde
      valorValido = true;
    } else {
      lcd.clear();
      lcd.print("Valor invalido!");
      digitalWrite(ledAmarelo, HIGH); // Acender LED amarelo (alerta)
      delay(2000);
      digitalWrite(ledAmarelo, LOW);  // Apagar LED amarelo
    }
  }
}

void extrato() {
  int usuarioAutenticado = autenticarUsuario();
  if (usuarioAutenticado == -1) {
    lcd.clear();
    lcd.print("Usuario nao encontrado!");
    digitalWrite(ledVermelho, HIGH); // Acender LED vermelho (erro)
    delay(2000);
    digitalWrite(ledVermelho, LOW);  // Apagar LED vermelho
    return;
  }

  lcd.clear();
  lcd.print("Saldo atual:");
  lcd.setCursor(0, 1);
  lcd.print(usuarios[usuarioAutenticado].saldo);

  // Verificar se o saldo está abaixo de um valor específico (por exemplo, 100)
  if (usuarios[usuarioAutenticado].saldo < 100) {
    digitalWrite(ledAmarelo, HIGH); // Acender LED amarelo (alerta de saldo baixo)
  } else {
    digitalWrite(ledVerde, HIGH); // Acender LED verde (sucesso)
  }

  delay(2000);
  digitalWrite(ledVerde, LOW);   // Apagar LED verde
  digitalWrite(ledAmarelo, LOW); // Apagar LED amarelo
}

// Função para realizar uma transferência
void transferencia() {
  int usuarioAutenticado = autenticarUsuario();
  if (usuarioAutenticado == -1) {
    lcd.clear();
    lcd.print("Usuario nao encontrado!");
    digitalWrite(ledVermelho, HIGH); // Acender LED vermelho (erro)
    delay(2000);
    digitalWrite(ledVermelho, LOW);  // Apagar LED vermelho
    return;
  }

  lcd.clear();
  lcd.print("Digite o nome do");
  lcd.setCursor(0, 1);
  lcd.print("destinatario:");
  delay(2000);

  char nomeDestinatario[20];
  memset(nomeDestinatario, 0, sizeof(nomeDestinatario)); // Limpar o buffer de entrada

  while (Serial.available() == 0) {
    ; // Fica no loop até que os dados estejam disponíveis para leitura
  }
  Serial.readBytesUntil('\n', nomeDestinatario, sizeof(nomeDestinatario) - 1); // Ler a entrada até o próximo caractere de nova linha
  limparCaracteresNaoImprimiveis(nomeDestinatario); // Limpar caracteres não imprimíveis

  lcd.clear();
  lcd.print("Digite o valor:");
  delay(2000);

  float valor = 0.0;
  char inputBuffer[10]; // Buffer para armazenar a entrada do usuário
  memset(inputBuffer, 0, sizeof(inputBuffer)); // Limpar o buffer de entrada

  while (Serial.available() == 0) {
    ; // Fica no loop até que os dados estejam disponíveis para leitura
  }
  Serial.readBytesUntil('\n', inputBuffer, sizeof(inputBuffer) - 1); // Ler a entrada até o próximo caractere de nova linha
  limparCaracteresNaoImprimiveis(inputBuffer); // Limpar caracteres não imprimíveis
  valor = atof(inputBuffer); // Converter a string lida para float

  // Verificar se o saldo é suficiente
  if (valor > usuarios[usuarioAutenticado].saldo) {
    lcd.clear();
    lcd.print("Saldo insuficiente");
    lcd.clear();
    lcd.print("Saldo insuficiente!");
    digitalWrite(ledAmarelo, HIGH); // Acender LED amarelo (alerta)
    delay(2000);
    digitalWrite(ledAmarelo, LOW);  // Apagar LED amarelo
    return;
  }

  // Procurar o destinatário
  int destinatarioEncontrado = -1;
  for (int i = 0; i < numUsuarios; i++) {
    if (strcmp(usuarios[i].nome, nomeDestinatario) == 0) {
      destinatarioEncontrado = i;
      break;
    }
  }

  if (destinatarioEncontrado == -1) {
    lcd.clear();
    lcd.print("Destinatario nao");
    lcd.setCursor(0, 1);
    lcd.print("encontrado!");
    digitalWrite(ledVermelho, HIGH); // Acender LED vermelho (erro)
    delay(2000);
    digitalWrite(ledVermelho, LOW);  // Apagar LED vermelho
    return;
  }

  // Realizar a transferência
  usuarios[usuarioAutenticado].saldo -= valor;
  usuarios[destinatarioEncontrado].saldo += valor;
  lcd.clear();
  lcd.print("Transferencia OK!");
  digitalWrite(ledVerde, HIGH); // Acender LED verde (sucesso)
  delay(2000);
  digitalWrite(ledVerde, LOW);  // Apagar LED verde
}

// Função para alterar a senha
void alterarSenha() {
  int usuarioAutenticado = autenticarUsuario();
  if (usuarioAutenticado == -1) {
    lcd.clear();
    lcd.print("Usuario nao encontrado!");
    digitalWrite(ledVermelho, HIGH); // Acender LED vermelho (erro)
    delay(2000);
    digitalWrite(ledVermelho, LOW);  // Apagar LED vermelho
    return;
  }

  lcd.clear();
  lcd.print("Digite a nova senha:");
  delay(2000);

  char novaSenha[10];
  memset(novaSenha, 0, sizeof(novaSenha)); // Limpar o buffer de entrada

  while (Serial.available() == 0) {
    ; // Fica no loop até que os dados estejam disponíveis para leitura
  }
  Serial.readBytesUntil('\n', novaSenha, sizeof(novaSenha) - 1); // Ler a entrada até o próximo caractere de nova linha
  limparCaracteresNaoImprimiveis(novaSenha); // Limpar caracteres não imprimíveis

  // Alterar a senha
  strcpy(usuarios[usuarioAutenticado].senha, novaSenha);
  lcd.clear();
  lcd.print("Senha alterada!");
  digitalWrite(ledVerde, HIGH); // Acender LED verde (sucesso)
  delay(2000);
  digitalWrite(ledVerde, LOW);  // Apagar LED verde
}

// Função para excluir a conta
void excluirConta() {
  int usuarioAutenticado = autenticarUsuario();
  if (usuarioAutenticado == -1) {
    lcd.clear();
    lcd.print("Usuario nao encontrado!");
    digitalWrite(ledVermelho, HIGH); // Acender LED vermelho (erro)
    delay(2000);
    digitalWrite(ledVermelho, LOW);  // Apagar LED vermelho
    return;
  }

  lcd.clear();
  lcd.print("Tem certeza? (s/n)");
  delay(2000);

  char resposta = 0;
  while (Serial.available() == 0) {
    ; // Fica no loop até que os dados estejam disponíveis para leitura
  }
  resposta = Serial.read();

  // Verificar a resposta do usuário
  if (resposta == 's' || resposta == 'S') {
    // Excluir a conta
    for (int i = usuarioAutenticado; i < numUsuarios - 1; i++) {
      usuarios[i] = usuarios[i + 1];
    }
    numUsuarios--;
    lcd.clear();
    lcd.print("Conta excluida!");
    digitalWrite(ledVerde, HIGH); // Acender LED verde (sucesso)
    delay(2000);
    digitalWrite(ledVerde, LOW);  // Apagar LED verde
  } else {
    lcd.clear();
    lcd.print("Operacao cancelada!");
    digitalWrite(ledAmarelo, HIGH); // Acender LED amarelo (alerta)
    delay(2000);
    digitalWrite(ledAmarelo, LOW);  // Apagar LED amarelo
  }
}


void setup() {
  Serial.begin(115200); // Inicializa a comunicação serial
  lcd.begin(16, 2);
  pinMode(btnUp, INPUT_PULLUP);
  pinMode(btnDown, INPUT_PULLUP);
  pinMode(btnSelect, INPUT_PULLUP);

  pinMode(ledVerde, OUTPUT);
  pinMode(ledAmarelo, OUTPUT);
  pinMode(ledVermelho, OUTPUT);

  inicializarUsuarios(); // Inicializar alguns usuários de teste

}

void loop() {
  // Verificar se algum botão foi pressionado
  if (digitalRead(btnUp) == LOW) {
    menuAtual = (menuAtual - 1 + 7) % 7;
  }
  if (digitalRead(btnDown) == LOW) {
    menuAtual = (menuAtual + 1) % 7;
  }
  if (digitalRead(btnSelect) == LOW) {
    switch (menuAtual) {
      case 0:
        cadastrarUsuario();
        break;
      case 1:
        deposito();
        break;
      case 2:
        saque();
        break;
      case 3:
        extrato();
        break;
      case 4:
        transferencia();
        break;
      case 5:
        alterarSenha();
        break;
      case 6:
        excluirConta();
        break;
    }
  }

  // Acender o LED verde
  digitalWrite(ledVerde, HIGH);

  // Apagar o LED amarelo
  digitalWrite(ledAmarelo, LOW);

  // Exibir o menu atual
  exibirMenu();
  lcd.setCursor(0, 1);
  switch (menuAtual) {
    case 0:
      lcd.print("1. Cadastrar usuario");
      break;
    case 1:
      lcd.print("2. Deposito");
      break;
    case 2:
      lcd.print("3. Saque");
      break;
    case 3:
      lcd.print("4. Extrato");
      break;
    case 4:
      lcd.print("5. Transferencia");
      break;
    case 5:
      lcd.print("6. Alterar senha");
      break;
    case 6:
      lcd.print("7. Excluir conta");
      break;
  }

  // Enviar informações pela porta serial
  Serial.print("Menu: ");
  Serial.println(menuAtual);
  Serial.print("Usuarios cadastrados: ");
  Serial.println(numUsuarios);

  delay(100);
}