// Pines para los segmentos del display (ánodo común)
#define segA 23
#define segB 22
#define segC 21
#define segD 19
#define segE 18
#define segF 5
#define segG 17
#define segDP 16

// Pines para los dígitos (multiplexado)
#define Dig1 4
#define Dig2 0
#define Dig3 2
#define Dig4 27

// Mapeo de caracteres: 0-9 y 'H' (apagado)
const bool caracteres[11][8] = {
  {1,1,1,1,1,1,0,0}, // 0
  {0,1,1,0,0,0,0,0}, // 1
  {1,1,0,1,1,0,1,0}, // 2
  {1,1,1,1,0,0,1,0}, // 3
  {0,1,1,0,0,1,1,0}, // 4
  {1,0,1,1,0,1,1,0}, // 5
  {1,0,1,1,1,1,1,0}, // 6
  {1,1,1,0,0,0,0,0}, // 7
  {1,1,1,1,1,1,1,0}, // 8
  {1,1,1,1,0,1,1,0}, // 9
  {0,0,0,0,0,0,0,0}  // H (apagado)
};

char displayChars[4] = {'H','H','H','H'};
bool displayPuntos[4] = {false,false,false,false};

void configurarPines() {
  pinMode(segA, OUTPUT); digitalWrite(segA, HIGH);
  pinMode(segB, OUTPUT); digitalWrite(segB, HIGH);
  pinMode(segC, OUTPUT); digitalWrite(segC, HIGH);
  pinMode(segD, OUTPUT); digitalWrite(segD, HIGH);
  pinMode(segE, OUTPUT); digitalWrite(segE, HIGH);
  pinMode(segF, OUTPUT); digitalWrite(segF, HIGH);
  pinMode(segG, OUTPUT); digitalWrite(segG, HIGH);
  pinMode(segDP, OUTPUT); digitalWrite(segDP, HIGH);

  pinMode(Dig1, OUTPUT); digitalWrite(Dig1, LOW);
  pinMode(Dig2, OUTPUT); digitalWrite(Dig2, LOW);
  pinMode(Dig3, OUTPUT); digitalWrite(Dig3, LOW);
  pinMode(Dig4, OUTPUT); digitalWrite(Dig4, LOW);
}

void mostrarCaracterEnDigito(int digito, char c, bool puntoDecimal) {
  int idx = 10;
  if (c >= '0' && c <= '9') idx = c - '0';

  bool seg[8];
  seg[0] = caracteres[idx][0];
  seg[1] = caracteres[idx][1];
  seg[2] = caracteres[idx][2];
  seg[3] = caracteres[idx][3];
  seg[4] = caracteres[idx][4];
  seg[5] = caracteres[idx][5];
  seg[6] = caracteres[idx][6];
  seg[7] = puntoDecimal;

  digitalWrite(segA, seg[0] ? LOW : HIGH);
  digitalWrite(segB, seg[1] ? LOW : HIGH);
  digitalWrite(segC, seg[2] ? LOW : HIGH);
  digitalWrite(segD, seg[3] ? LOW : HIGH);
  digitalWrite(segE, seg[4] ? LOW : HIGH);
  digitalWrite(segF, seg[5] ? LOW : HIGH);
  digitalWrite(segG, seg[6] ? LOW : HIGH);
  digitalWrite(segDP, seg[7] ? LOW : HIGH);

  int pinDig = (digito == 0) ? Dig1 : (digito == 1) ? Dig2 : (digito == 2) ? Dig3 : Dig4;
  digitalWrite(pinDig, HIGH);
  delay(2);
  digitalWrite(pinDig, LOW);

  digitalWrite(segA, HIGH); digitalWrite(segB, HIGH);
  digitalWrite(segC, HIGH); digitalWrite(segD, HIGH);
  digitalWrite(segE, HIGH); digitalWrite(segF, HIGH);
  digitalWrite(segG, HIGH); digitalWrite(segDP, HIGH);
}

void actualizarDisplayDesdeCadena(const char* cadena) {
  displayChars[0] = 'H'; displayChars[1] = 'H';
  displayChars[2] = 'H'; displayChars[3] = 'H';
  displayPuntos[0] = false; displayPuntos[1] = false;
  displayPuntos[2] = false; displayPuntos[3] = false;

  if (cadena[0] == '\0') return;
  if (cadena[0] == '.' && cadena[1] == '.' && cadena[2] == '.' && cadena[3] == '.') {
    displayChars[0] = 'H'; displayPuntos[0] = true;
    displayChars[1] = 'H'; displayPuntos[1] = true;
    displayChars[2] = 'H'; displayPuntos[2] = true;
    displayChars[3] = 'H'; displayPuntos[3] = true;
    return;
  }

  int i = 0, pos = 0;
  while (cadena[i] != '\0') {
    if (cadena[i] >= '0' && cadena[i] <= '9') {
      if (pos < 4) {
        displayChars[pos] = cadena[i];
        displayPuntos[pos] = false;
        pos++;
      }
    } else if (cadena[i] == '.') {
      if (pos > 0) displayPuntos[pos - 1] = true;
    } else if (cadena[i] == 'H' && pos < 4) {
      displayChars[pos] = 'H';
      displayPuntos[pos] = false;
      pos++;
    }
    i++;
  }
}

void mostrarInstrucciones() {
  const char* mensaje =
    "\n======================================\n"
    "   DISPLAY 7 SEGMENTOS SERIAL \n"
    "======================================\n"
    "¿COMO SE USA?\n"
    " - Escribe un numero o patron en el monitor serial.\n"
    " - Ejemplos validos:\n"
    "     1234   -> muestra los digitos 1 2 3 4\n"
    "     56.7   -> muestra 5 6. 7 (punto decimal activo)\n"
    "     ....   -> solo puntos decimales encendidos\n"
    "     H78.   -> primer digito apagado, luego 7 8.\n"
    "     00.1   -> ceros a la izquierda, punto decimal\n"
    "\n"
    "¿QUE PUEDE HACER?\n"
    " - Mostrar numeros de 0 a 9 (hasta 4 digitos)\n"
    " - Encender/apagar punto decimal\n"
    " - Apagar digitos individualmente con 'H'\n"
    "\n"
    "¿QUE NO PUEDE HACER?\n"
    " - No muestra letras (solo 'H' para apagar)\n"
    " - No interpreta negativos ni decimales reales\n"
    " - No valida cadenas incorrectas\n"
    "\n>>> Escribe un numero (Ej: 12.34 o H78.):\n";

  int i = 0;
  while (mensaje[i] != '\0') {
    Serial.write(mensaje[i]);
    i++;
  }
}

void loop() {
  mostrarCaracterEnDigito(0, displayChars[0], displayPuntos[0]);
  mostrarCaracterEnDigito(1, displayChars[1], displayPuntos[1]);
  mostrarCaracterEnDigito(2, displayChars[2], displayPuntos[2]);
  mostrarCaracterEnDigito(3, displayChars[3], displayPuntos[3]);

  if (Serial.available()) {
    String entrada = Serial.readStringUntil('\n');
    entrada.trim();
    char buffer[10];
    entrada.toCharArray(buffer, 10);
    actualizarDisplayDesdeCadena(buffer);
    Serial.print("Dato actualizado: ");
    Serial.println(buffer);
  }
}

void setup() {
  configurarPines();
  Serial.begin(115200);
  delay(500);
  mostrarInstrucciones();
}