// Programa para manejar pulsadores y mostrar información en pantalla OLED 0.96"
// Pulsadores conectados en pines: 19, 18, 17, 16 (pin 19 es el menos significativo)
// Pantalla OLED conectada: SDA=21, SCL=22

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// Configuración de la pantalla OLED 0.96" (128x64)
#define ANCHO_PANTALLA 128
#define ALTO_PANTALLA 64
#define DIRECCION_OLED 0x3C
#define PIN_SDA 21
#define PIN_SCL 22

// Crear objeto de la pantalla OLED
Adafruit_SSD1306 pantalla(ANCHO_PANTALLA, ALTO_PANTALLA, &Wire, -1);

// Definición de pines de pulsadores (del menos significativo al más significativo)
// Pines recomendados: 19, 18, 17, 16 (más estables, sin funciones especiales)
const int pin_pulsadores[] = {19, 18, 17, 16};
const int num_pulsadores = 4;

// Definición de pines de LEDs (del menos significativo al más significativo)
const int pin_leds[] = {25, 26, 27, 14, 12, 13};
const int num_leds = 6;

// Variables para el estado de los pulsadores
bool estado_pulsadores[num_pulsadores];
bool estado_anterior[num_pulsadores];

// Variables para debounce
unsigned long ultimo_tiempo[num_pulsadores];
const unsigned long tiempo_debounce = 100; // 100ms (aumentado para mayor estabilidad)

void setup() {
  // Inicializar comunicación serie
  Serial.begin(115200);
  Serial.println("Sistema OLED con pulsadores iniciado");
  
  // Inicializar pantalla OLED
  if (!pantalla.begin(SSD1306_SWITCHCAPVCC, DIRECCION_OLED)) {
    Serial.println("Error al inicializar pantalla OLED");
    while (1);
  }
  
  // Limpiar pantalla y mostrar mensaje inicial
  pantalla.clearDisplay();
  pantalla.setTextSize(1);
  pantalla.setTextColor(SSD1306_WHITE);
  pantalla.setCursor(0, 0);
  pantalla.println("Sistema iniciado");
  pantalla.println("Pulsadores:");
  pantalla.println("19(LSB), 18, 17, 16(MSB)");
  pantalla.display();
  delay(2000);
  
  // Configurar pines de pulsadores como entradas (con resistencias pull-down externas)
  for (int i = 0; i < num_pulsadores; i++) {
    pinMode(pin_pulsadores[i], INPUT);
    
    // Los nuevos pines (16, 17, 18, 19) no requieren configuración especial
    // Son pines GPIO normales sin funciones especiales
    
    estado_pulsadores[i] = digitalRead(pin_pulsadores[i]); // HIGH = presionado, LOW = soltado
    estado_anterior[i] = estado_pulsadores[i];
    ultimo_tiempo[i] = 0;
  }
  
  // Configurar pines de LEDs como salidas
  for (int i = 0; i < num_leds; i++) {
    pinMode(pin_leds[i], OUTPUT);
    digitalWrite(pin_leds[i], LOW); // Apagar todos los LEDs
  }
  
  Serial.println("Pulsadores: 19(LSB), 18, 17, 16(MSB)");
}

void loop() {
  // Leer estado de todos los pulsadores
  leer_pulsadores();
  
  // Obtener el valor binario de la combinación de pulsadores
  int valor_binario = obtener_valor_binario();
  
  // Mostrar información en consola
  Serial.print("Combinación: ");
  for (int i = num_pulsadores - 1; i >= 0; i--) {
    Serial.print(estado_pulsadores[i] ? "1" : "0");
  }
  Serial.print(" = ");
  Serial.print(valor_binario);
  Serial.print(" (decimal)");
  
  // Controlar LEDs según las condiciones
  controlar_leds(valor_binario);
  
  // Mostrar información en pantalla OLED
  mostrar_en_pantalla(valor_binario);
  
  delay(100); // Pequeña pausa para estabilidad
}

// Función para leer el estado de los pulsadores con debounce mejorado
void leer_pulsadores() {
  unsigned long tiempo_actual = millis();
  
  for (int i = 0; i < num_pulsadores; i++) {
    bool lectura = digitalRead(pin_pulsadores[i]); // HIGH = presionado, LOW = soltado
    
    // Si el estado cambió y ha pasado suficiente tiempo (debounce)
    if (lectura != estado_anterior[i] && (tiempo_actual - ultimo_tiempo[i]) > tiempo_debounce) {
      // Verificación adicional: leer múltiples veces para confirmar el cambio
      bool lectura_confirmada = true;
      for (int j = 0; j < 3; j++) {
        delay(5);
        if (digitalRead(pin_pulsadores[i]) != lectura) {
          lectura_confirmada = false;
          break;
        }
      }
      
      if (lectura_confirmada) {
        estado_pulsadores[i] = lectura;
        ultimo_tiempo[i] = tiempo_actual;
        Serial.print("Pulsador ");
        Serial.print(pin_pulsadores[i]);
        Serial.print(" cambió a: ");
        Serial.println(lectura ? "HIGH" : "LOW");
      }
    }
    
    estado_anterior[i] = lectura;
  }
}

// Función para obtener el valor decimal de la combinación binaria
int obtener_valor_binario() {
  int valor = 0;
  
  // Construir el número binario (pin 19 es LSB, pin 16 es MSB)
  for (int i = 0; i < num_pulsadores; i++) {
    if (estado_pulsadores[i]) { // Si el pulsador está presionado (HIGH)
      valor |= (1 << i);
    }
  }
  
  return valor;
}

// Función para controlar los LEDs según las condiciones
void controlar_leds(int valor) {
  // Apagar todos los LEDs primero
  for (int i = 0; i < num_leds; i++) {
    digitalWrite(pin_leds[i], LOW);
  }
  
  // Condición 1: LED menos significativo (pin 25) si la combinación es par
  if (es_par(valor)) {
    digitalWrite(pin_leds[0], HIGH); // Pin 25 (índice 0)
  }
  
  // Condición 2: LED siguiente (pin 26) si la combinación es impar
  if (es_impar(valor)) {
    digitalWrite(pin_leds[1], HIGH); // Pin 26 (índice 1)
  }
  
  // Condición 3: LED siguiente (pin 27) si la combinación es primo
  if (es_primo(valor)) {
    digitalWrite(pin_leds[2], HIGH); // Pin 27 (índice 2)
  }
}

// Función para mostrar información en la pantalla OLED
void mostrar_en_pantalla(int valor) {
  // Limpiar pantalla
  pantalla.clearDisplay();
  
  // Configurar texto
  pantalla.setTextSize(1);
  pantalla.setTextColor(SSD1306_WHITE);
  
  // Mostrar número binario
  pantalla.setCursor(0, 0);
  pantalla.print("Binario: ");
  for (int i = num_pulsadores - 1; i >= 0; i--) {
    pantalla.print(estado_pulsadores[i] ? "1" : "0");
  }
  
  // Mostrar número decimal
  pantalla.setCursor(0, 12);
  pantalla.print("Decimal: ");
  pantalla.print(valor);
  
  // Mostrar PAR o IMPAR
  pantalla.setCursor(0, 24);
  if (es_par(valor)) {
    pantalla.print("PAR");
    Serial.print(" - PAR");
  } else {
    pantalla.print("IMPAR");
    Serial.print(" - IMPAR");
  }
  
  // Mostrar PRIMO o NO PRIMO
  pantalla.setCursor(0, 36);
  if (es_primo(valor)) {
    pantalla.print("PRIMO");
    Serial.print(" - PRIMO");
  } else {
    pantalla.print("NO PRIMO");
  }
  
  // Mostrar estado de pulsadores individuales
  pantalla.setCursor(0, 48);
  pantalla.print("Pulsadores: ");
  for (int i = num_pulsadores - 1; i >= 0; i--) {
    pantalla.print(estado_pulsadores[i] ? "1" : "0");
  }
  
  // Actualizar pantalla
  pantalla.display();
  
  Serial.println(); // Nueva línea en consola
}

// Función para verificar si un número es par
bool es_par(int numero) {
  return (numero % 2 == 0);
}

// Función para verificar si un número es impar
bool es_impar(int numero) {
  return (numero % 2 == 1);
}

// Función para verificar si un número es primo
bool es_primo(int numero) {
  if (numero < 2) return false;
  if (numero == 2) return true;
  if (numero % 2 == 0) return false;
  
  for (int i = 3; i * i <= numero; i += 2) {
    if (numero % i == 0) return false;
  }
  
  return true;
}