#include <Keypad.h>

// --- 1. CONFIGURACIÓN DEL TECLADO MATRICIAL ---
const byte FILAS = 4;
const byte COLUMNAS = 4;

// Mapa visual de los botones del teclado
char teclas[FILAS][COLUMNAS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};

// Pines conectados a las filas y columnas
byte pinesFilas[FILAS] = {39, 38, 37, 36}; 
byte pinesColumnas[COLUMNAS] = {35, 0, 45, 48}; 

Keypad teclado = Keypad(makeKeymap(teclas), pinesFilas, pinesColumnas, FILAS, COLUMNAS);

// --- 2. CONFIGURACIÓN DE PINES (PANTALLA) ---
// Pines que activan cada uno de los 4 "bloques" de la pantalla
int digitos[4] = {15, 16, 17, 18};

// Pines de las "rayitas" (segmentos A, B, C, D, E, F, G)
int segmentos[7] = {8, 3, 46, 9, 10, 11, 12};

// Tabla para dibujar los números del 0 al 9
int valores[10][7] = {
  {1,1,1,1,1,1,0}, // 0
  {0,1,1,0,0,0,0}, // 1
  {1,1,0,1,1,0,1}, // 2
  {1,1,1,1,0,0,1}, // 3
  {0,1,1,0,0,1,1}, // 4
  {1,0,1,1,0,1,1}, // 5
  {1,0,1,1,1,1,1}, // 6
  {1,1,1,0,0,0,0}, // 7
  {1,1,1,1,1,1,1}, // 8
  {1,1,1,1,0,1,1}  // 9
};

// --- 3. VARIABLES DE MEMORIA (Para guardar lo que tecleas) ---
// Usamos -1 para representar que ese espacio de la pantalla está "vacío" o apagado
int buffer[4] = {-1, -1, -1, -1}; 
int indice = 0;         // Nos dice en qué posición (0, 1, 2 o 3) vamos a escribir el próximo número
bool congelado = false; // Bandera para saber si bloqueamos la pantalla con el botón '#'

// --- 4. PREPARACIÓN INICIAL ---
void setup() {
  // Configura los segmentos como SALIDA y los apaga (HIGH apaga en Ánodo Común)
  for(int i = 0; i < 7; i++) {
    pinMode(segmentos[i], OUTPUT);
    digitalWrite(segmentos[i], HIGH); 
  }
  
  // Configura los dígitos como SALIDA y los apaga (LOW apaga los dígitos en Ánodo Común)
  for(int i = 0; i < 4; i++) {
    pinMode(digitos[i], OUTPUT);
    digitalWrite(digitos[i], LOW); 
  }
}

// --- 5. CICLO PRINCIPAL ---
void loop() {
  
  // --- FASE A: LEER EL TECLADO ---
  char tecla = teclado.getKey(); // Revisa si se presionó un botón

  if(tecla) { 
    if(tecla == '*') {
      // Botón '*': Funciona como "Borrar Todo"
      for(int i = 0; i < 4; i++) buffer[i] = -1; // Llena la pantalla de espacios vacíos
      indice = 0;         // Regresa el cursor al inicio
      congelado = false;  // Desbloquea la pantalla para poder volver a escribir
      
    } else if(!congelado) {
      // Si la pantalla NO está congelada, permitimos escribir números o bloquearla
      
      if(tecla >= '0' && tecla <= '9') {
        // Si presionaste un número y aún hay espacio (no hemos llegado a 4 dígitos)
        if(indice < 4) {
          buffer[indice] = tecla - '0'; // Truco para convertir la tecla texto ('5') en número real (5)
          indice++;                     // Avanza a la siguiente posición
        }
      } else if(tecla == '#') {
        // Botón '#': Congela la pantalla (ya no deja agregar más números hasta borrar con '*')
        congelado = true; 
      }
    }
  }

  // --- FASE B: MULTIPLEXACIÓN (Dibujar en pantalla) ---
  for(int i = 0; i < 4; i++) {
    
    // 1. Revisamos si hay un número válido guardado en esta posición
    if(buffer[i] >= 0) {
      // Si hay un número (0-9), cargamos su patrón. Invertimos con "!" por ser Ánodo Común.
      for(int j = 0; j < 7; j++) {
        digitalWrite(segmentos[j], !valores[buffer[i]][j]);
      }
    } else {
      // Si es -1 (vacío), apagamos todos los segmentos de esa posición
      for(int j = 0; j < 7; j++) {
        digitalWrite(segmentos[j], HIGH); // HIGH = Apagado total
      }
    }

    // 2. Enciende el "bloque" de la posición actual
    digitalWrite(digitos[i], HIGH);
    
    // 3. Pausa muy rápida para engañar al ojo
    delay(3); 
    
    // 4. Apaga la posición antes de pasar a la siguiente para que no se mezclen los números
    digitalWrite(digitos[i], LOW);
  }
}