// === Dado electrónico - versión no bloqueante con entrada múltiple ===
// STM32 Nucleo F446RE - Ánodo común

const int segmentos[7] = {2, 3, 4, 5, 6, 7, 8};
const unsigned long TIEMPO_CAMBIO = 1000; // 1 s por número
unsigned long tiempoAnterior = 0;
int indice = 0;

// === Variables ===
String nombre = "";         // nombre actualmente en uso
String nombrePendiente = ""; // nombre nuevo pendiente
int numeros[60];
int total = 0;
bool listo = false;
bool hayCambioPendiente = false;

// === Mapa alfabético ===
int letraANum(char c) {
  c = toupper(c);
  if (c >= 'A' && c <= 'Z') return (c - 'A' + 1);
  return 0;
}

// === Tabla de dígitos ===
const int digitos[10][7] = {
  {1,1,1,1,1,1,0}, {0,1,1,0,0,0,0}, {1,1,0,1,1,0,1},
  {1,1,1,1,0,0,1}, {0,1,1,0,0,1,1}, {1,0,1,1,0,1,1},
  {1,0,1,1,1,1,1}, {1,1,1,0,0,0,0}, {1,1,1,1,1,1,1}, {1,1,1,1,0,1,1}
};

// === Funciones de display ===
void mostrarNumero(int num) {
  for (int i = 0; i < 7; i++) {
    digitalWrite(segmentos[i], digitos[num][i] ? LOW : HIGH);
  }
}

void apagarDisplay() {
  for (int i = 0; i < 7; i++) digitalWrite(segmentos[i], HIGH);
}

// === Procesa un nombre y genera su secuencia ===
void procesarNombre(String nom) {
  Serial.print("Procesando nombre: ");
  Serial.println(nom);
// --- 1) Imprimir la secuencia DE VALORES (no divididos) ---
  Serial.print("Secuencia completa: ");
  bool primero = true;
  for (int i = 0; i < nom.length(); i++) {
    int n = letraANum(nom[i]);
    if (n > 0) {
      if (!primero) Serial.print(", ");
      Serial.print(n);
      primero = false;
    }
  }
  Serial.println();

  total = 0;
  for (int i = 0; i < nom.length(); i++) {
    int n = letraANum(nom[i]);
    if (n >= 10) {
      numeros[total++] = n / 10;
      numeros[total++] = n % 10;
    } else if (n > 0) {
      numeros[total++] = n;
    }
  }

  Serial.print("Secuencia en display: ");
  for (int i = 0; i < total; i++) {
    Serial.print(numeros[i]);
    if (i < total - 1) Serial.print(", ");
  }
  Serial.println();
  Serial.println("--------------------------");
  
  indice = 0;
  tiempoAnterior = millis();
  mostrarNumero(numeros[0]);
}

// === Setup ===
void setup() {
  for (int i = 0; i < 7; i++) pinMode(segmentos[i], OUTPUT);
  apagarDisplay();

  Serial.begin(115200);
  delay(500);

  Serial.println("====================================");
  Serial.println("  DADO ELECTRÓNICO - NOMBRE EN DISPLAY");
  Serial.println("====================================");
  Serial.println("Ingresa tu nombre (solo letras) y presiona ENTER:");
}

// === Loop ===
void loop() {

  // 1. SIEMPRE podemos recibir nombres nuevos sin interferir
  if (Serial.available() > 0) {
    nombrePendiente = Serial.readStringUntil('\n');
    nombrePendiente.trim();
    nombrePendiente.toUpperCase();

    Serial.print("Nuevo nombre recibido: ");
    Serial.println(nombrePendiente);

    hayCambioPendiente = true;  // marcar que hay un nombre esperando
  }

  // 2. Si aún no hay nombre procesado, procesamos el primero
  if (!listo && hayCambioPendiente) {
    nombre = nombrePendiente;
    procesarNombre(nombre);
    listo = true;
    hayCambioPendiente = false;
  }

  // 3. Mostrar secuencia no bloqueante
  if (listo && total > 0) {
    unsigned long ahora = millis();
    if (ahora - tiempoAnterior >= TIEMPO_CAMBIO) {

      indice++;

      // Si se terminó la vuelta completa
      if (indice >= total) {
        indice = 0;

        // Si hay un nuevo nombre esperando → ahora sí cambiar
        if (hayCambioPendiente) {
          nombre = nombrePendiente;
          procesarNombre(nombre);
          hayCambioPendiente = false;
          return;
        }
      }

      mostrarNumero(numeros[indice]);
      tiempoAnterior = ahora;
    }
  }
}