#include <MD_MAX72xx.h>

// Número total de matrices LED (informativo, no usado en la inicialización individual)
// #define NUM_MATRICES 2 // Ya no es necesario para la inicialización así

// Zonas sensibilidad joystick
#define ZONA_MUERTA 100
#define CENTRO 512

// Límites Joystick
#define LIMITE_INFERIOR (CENTRO - ZONA_MUERTA)
#define LIMITE_SUPERIOR (CENTRO + ZONA_MUERTA)

// Límites Matriz de Juego (Matriz 1)
const int maxX = 7; // Máximo X para una matriz 8x8 (0-7)
const int maxY = 7; // Máximo Y para una matriz 8x8 (0-7)

// --- Pines Matriz 1 (Juego) ---
#define PIN_CLK_JUEGO  13
#define PIN_DATO_JUEGO 11
#define PIN_CS_JUEGO   10 // CS para la matriz del juego

// --- Pines Matriz 2 (Puntuación) ---
#define PIN_CLK_PUNTOS  5  // Asegúrate que estos pines son correctos
#define PIN_DATO_PUNTOS 7  // Asegúrate que estos pines son correctos
#define PIN_CS_PUNTOS   6  // CS para la matriz de puntuación

// Joystick
#define PIN_VERT A0 // 0-1025
#define PIN_HORZ A1
#define PIN_SEL  2

// Variable contador
int contador = 0;

// --- Crear objetos MD_MAX72XX separados ---
// Objeto para la matriz del juego (1 matriz en el pin CS_JUEGO)
MD_MAX72XX matrizJuego = MD_MAX72XX(MD_MAX72XX::PAROLA_HW, PIN_DATO_JUEGO, PIN_CLK_JUEGO, PIN_CS_JUEGO, 1);
// Objeto para la matriz de puntuación (1 matriz en el pin CS_PUNTOS)
MD_MAX72XX matrizPuntos = MD_MAX72XX(MD_MAX72XX::PAROLA_HW, PIN_DATO_PUNTOS, PIN_CLK_PUNTOS, PIN_CS_PUNTOS, 1);
// Nota: El constructor puede variar ligeramente según la versión de la librería.
// Si el anterior no funciona, prueba este formato que especifica HW y CS primero:
// MD_MAX72XX matrizJuego = MD_MAX72XX(MD_MAX72XX::PAROLA_HW, PIN_CS_JUEGO, 1);
// MD_MAX72XX matrizPuntos = MD_MAX72XX(MD_MAX72XX::PAROLA_HW, PIN_CS_PUNTOS, 1);
// ¡Asegúrate de que los pines DATA y CLK también estén conectados correctamente para cada matriz!


int x = 0, y = 0;          // Punto del jugador (en matrizJuego)
int puntoX = 5, puntoY = 5; // Punto objetivo aleatorio (en matrizJuego)

const int DISTANCIA_MINIMA = 2; // Mínima distancia entre jugador y punto

// Declaración de la matriz de números (sin cambios)
byte numeros[10][8] = {
  { B00111100, B01100110, B01101110, B01110110, B01100110, B01100110, B00111100, B00000000 }, // 0
  { B00011000, B00111000, B00011000, B00011000, B00011000, B00011000, B01111110, B00000000 }, // 1
  { B00111100, B01100110, B00000110, B00001100, B00110000, B01100000, B01111110, B00000000 }, // 2
  { B00111100, B01100110, B00000110, B00011100, B00000110, B01100110, B00111100, B00000000 }, // 3
  { B00001100, B00011100, B00101100, B01001100, B01111110, B00001100, B00001100, B00000000 }, // 4
  { B01111110, B01100000, B01111100, B00000110, B00000110, B01100110, B00111100, B00000000 }, // 5
  { B00111100, B01100110, B01100000, B01111100, B01100110, B01100110, B00111100, B00000000 }, // 6
  { B01111110, B01100110, B00000110, B00001100, B00011000, B00011000, B00011000, B00000000 }, // 7
  { B00111100, B01100110, B01100110, B00111100, B01100110, B01100110, B00111100, B00000000 }, // 8
  { B00111100, B01100110, B01100110, B00111110, B00000110, B01100110, B00111100, B00000000 }  // 9
};

void setup() {
  // Inicializar matriz de Juego
  matrizJuego.begin();
  matrizJuego.control(MD_MAX72XX::INTENSITY, MAX_INTENSITY / 2);
  matrizJuego.clear();

  // Inicializar matriz de Puntuación
  matrizPuntos.begin();
  matrizPuntos.control(MD_MAX72XX::INTENSITY, MAX_INTENSITY / 2);
  matrizPuntos.clear();

  pinMode(PIN_VERT, INPUT);
  pinMode(PIN_HORZ, INPUT);
  pinMode(PIN_SEL, INPUT_PULLUP);

  randomSeed(analogRead(A2)); // Semilla para generar números aleatorios
  generarNuevoPunto();        // Crear primer punto aleatorio
}

void loop() {
  int horz = analogRead(PIN_HORZ);
  int vert = analogRead(PIN_VERT);

  // --- Movimiento del Jugador (controla x, y) ---
  int prevX = x;
  int prevY = y;
  bool moved = false;

  if (vert < LIMITE_INFERIOR) {
    y = min(y + 1, maxY); // Abajo
    moved = true;
  }
  if (vert > LIMITE_SUPERIOR) {
    y = max(y - 1, 0);     // Arriba
    moved = true;
  }
  if (horz > LIMITE_SUPERIOR) {
    x = min(x + 1, maxX); // Derecha
    moved = true;
  }
  if (horz < LIMITE_INFERIOR) {
    x = max(x - 1, 0);     // Izquierda
    moved = true;
  }

  // Si se presiona el botón del joystick, limpiar ambas matrices y reiniciar contador
  if (digitalRead(PIN_SEL) == LOW) {
    matrizJuego.clear();
    matrizPuntos.clear();
    contador = 0;
    mostrarNumero(contador); // Actualizar puntaje a 0 en pantalla
    x = 0; // Reiniciar posición jugador
    y = 0;
    generarNuevoPunto(); // Generar nuevo punto
    delay(200); // Pequeña pausa para evitar múltiples resets
  }

  // --- Lógica del Juego ---
  // Revisar si el jugador alcanzó el punto aleatorio
  if (x == puntoX && y == puntoY) {
    generarNuevoPunto();
    contador++; // Aumento el contador para la puntuación
    if (contador > 9) contador = 0; // Reiniciar si pasa de 9 (o ajustar límite)
    mostrarNumero(contador); // Actualizar la matriz de puntos INMEDIATAMENTE
  }

  // --- Actualizar Pantallas ---

  // 1. Limpiar la matriz de juego antes de redibujar
  matrizJuego.clear(); // Solo limpiar si hubo movimiento o colisión (más eficiente, pero clear() es más simple)

  // 2. Dibujar el jugador y el punto objetivo en la matriz de juego
  matrizJuego.setPoint(y, x, true);       // Jugador
  matrizJuego.setPoint(puntoY, puntoX, true); // Punto objetivo




  delay(100); // Retardo para la visualización y control de velocidad
}

void generarNuevoPunto() {
  // Asegurarse que el nuevo punto no aparezca exactamente donde está el jugador
  do {
    puntoX = random(0, maxX + 1); // Rango 0 a 7
    puntoY = random(0, maxY + 1); // Rango 0 a 7
  } while (puntoX == x && puntoY == y); // Evita superposición inicial simple

  // Opcional: Mantener la distancia mínima (como tenías antes)
  // } while (abs(puntoX - x) <= DISTANCIA_MINIMA && abs(puntoY - y) <= DISTANCIA_MINIMA);
}

// Función para mostrar el número en la SEGUNDA matriz (matrizPuntos)
void mostrarNumero(byte numero) {
  if (numero > 9) numero = 9; // Limita a 9

  matrizPuntos.clear(); // Limpiar la matriz de puntos antes de escribir el nuevo número

  for (int fila = 0; fila < 8; fila++) {
    // Usar el objeto matrizPuntos y asumir que es la matriz 0 de ESE objeto
    matrizPuntos.setRow(0, fila, numeros[numero][fila]);
  }
  
}