/*
 * Proyecto 6: Juego de Círculo Inclinado - Matriz LED RGB ESP32-S3 (Waveshare)
 * 
 * Este boceto lee la inclinación del IMU QMI8658C y mueve suavemente un punto en la matriz LED RGB de 8×8 según la orientación de la placa.
 * 
 * ▶️ Tutorial en Video:
 * https://youtu.be/JKLuYrRcLMI
 * 
 * 📚⬇️ Recursos y Página de Código:
 * https://robojax.com/RJT829
 * 
 * QMI8658_RGB_2
 */
#include <Arduino.h>
#include <math.h>

#include <Adafruit_GFX.h>
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h>

#include <QMI8658.h> // por Lahav Gahali

 // -------- CONFIGURACIÓN DE MATRIZ LED --------
#define MATRIX_PIN    14
#define MATRIX_WIDTH  8
#define MATRIX_HEIGHT 8

 // Pin del zumbador - cámbialo por el GPIO de tu zumbador real.
const int BUZZER_PIN = 6; // TODO: establece tu pin del timbre

 // Brillo de la matriz (0-255)
const uint8_t MATRIX_BRIGHTNESS = 10;

Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(
  MATRIX_WIDTH, MATRIX_HEIGHT, MATRIX_PIN,
  NEO_MATRIX_TOP + NEO_MATRIX_LEFT +
  NEO_MATRIX_ROWS + NEO_MATRIX_PROGRESSIVE,
  NEO_GRB + NEO_KHZ800
);

 // -------- CONFIGURACIÓN DEL IMU --------
QMI8658 imu;

 // -------- CONFIGURACIÓN DEL JUEGO --------

 // Con qué frecuencia se permite mover el punto (ms).
 // Más grande = movimiento más lento.
const uint16_t MOVE_INTERVAL_MS = 150; // intenta 120-250

 // ¿Cuánto inclinación (m/s^2) antes de que el punto se mueva?
 // Aumenta si se siente demasiado sensible.
const float ACC_TILT_THRESHOLD = 2.0f; // aproximadamente ~0.2 g

 // Color base del punto (RGB)
const uint8_t DOT_R = 255;
const uint8_t DOT_G = 255;
const uint8_t DOT_B = 255;


 // Geometría de círculos (centrado en 8x8)
const float CIRCLE_CENTER_X = (MATRIX_WIDTH - 1) / 2.0f; // 3.5
const float CIRCLE_CENTER_Y = (MATRIX_HEIGHT - 1) / 2.0f; // 3.5
const float CIRCLE_RADIUS   = 3.0f;
const float CIRCLE_THICKNESS = 0.8f; // +- grosor alrededor del radio

 // -------- ESTADO DEL JUEGO --------

 // Posición del punto en la cuadrícula 8x8 (0..7)
int dotX = 3;
int dotY = 3;

 // Colores (colores NeoMatrix de 16 bits)
uint16_t dotColor;
uint16_t circleColor;

 // Para detectar "círculo recién tocado" frente a "todavía en el círculo"
bool wasOnCircle = false;

 // Temporizador para limitar el movimiento
unsigned long lastMoveTime = 0;

 // -------- FUNCIONES AYUDANTES --------

 // Rueda de colores NeoPixel clásica (0-255 -> arcoíris)
uint16_t wheel(byte pos) {
  if (pos < 85) {
    return matrix.Color(pos * 3, 255 - pos * 3, 0);
  } else if (pos < 170) {
    pos -= 85;
    return matrix.Color(255 - pos * 3, 0, pos * 3);
  } else {
    pos -= 170;
    return matrix.Color(0, pos * 3, 255 - pos * 3);
  }
}

 // ¿Está un píxel dado aproximadamente en el círculo?
bool isOnCircle(int x, int y) {
  float dx = x - CIRCLE_CENTER_X;
  float dy = y - CIRCLE_CENTER_Y;
  float d2 = dx * dx + dy * dy;

  float rMin = CIRCLE_RADIUS - CIRCLE_THICKNESS;
  float rMax = CIRCLE_RADIUS + CIRCLE_THICKNESS;

  return (d2 >= rMin * rMin) && (d2 <= rMax * rMax);
}

 // Dibuja un círculo + un punto
void drawScene() {
  matrix.fillScreen(0);

 // Dibuja un círculo
  for (int y = 0; y < MATRIX_HEIGHT; y++) {
    for (int x = 0; x < MATRIX_WIDTH; x++) {
      if (isOnCircle(x, y)) {
        matrix.drawPixel(x, y, circleColor);
      }
    }
  }

 // Dibuja un punto (en la parte superior)
  matrix.drawPixel(dotX, dotY, dotColor);

  matrix.show();
}

 // Beep de bloqueo simple (corto)
void buzzOnce() {
  digitalWrite(BUZZER_PIN, HIGH);
  delay(40);
  digitalWrite(BUZZER_PIN, LOW);
}

 // Utiliza el acelerómetro para decidir el movimiento del punto.
void updateDotFromTilt(float ax, float ay) {
  unsigned long now = millis();
  if (now - lastMoveTime < MOVE_INTERVAL_MS) {
    return; // demasiado pronto, espera
  }

  int dx = 0;
  int dy = 0;

 // En esta placa, la inclinación Y se siente como "izquierda/derecha" en la matriz.
 // y la inclinación X se siente como "arriba/abajo" → así que intercambiamos.

 // --- Movimiento horizontal desde AY (inclinación izquierda/derecha) ---
  if (ay > ACC_TILT_THRESHOLD) {
    dx = 1; // inclina hacia la derecha → mueve el punto hacia la derecha
  } else if (ay < -ACC_TILT_THRESHOLD) {
    dx = -1; // inclina hacia la izquierda → mueve el punto hacia la izquierda
  }

 // --- Movimiento vertical desde AX (inclinar hacia adelante/atrás) ---
 // Esto fue invertido. Cambiamos los signos:
 // ax > umbral = inclinar "hacia adelante" (lejos) → mover punto ARRIBA (dy = -1)
 // ax < -umbral = inclinación "hacia atrás" (hacia) → mover punto ABAJO (dy = 1)
  if (ax > ACC_TILT_THRESHOLD) {
    dy = -1; // estaba +1 antes
  } else if (ax < -ACC_TILT_THRESHOLD) {
    dy = 1; // era -1 antes
  }

  if (dx != 0 || dy != 0) {
    dotX = constrain(dotX + dx, 0, MATRIX_WIDTH  - 1);
    dotY = constrain(dotY + dy, 0, MATRIX_HEIGHT - 1);
    lastMoveTime = now;
  }
}


 // -------- CONFIGURACIÓN Y BUCLE --------

void setup() {
  Serial.begin(115200);
  delay(100);

 // Inicialización de matriz
  matrix.begin();
  matrix.setBrightness(MATRIX_BRIGHTNESS);
  matrix.fillScreen(0);
  matrix.show();

 // Inicialización del temporizador
  pinMode(BUZZER_PIN, OUTPUT);
  digitalWrite(BUZZER_PIN, LOW);

 // IMU inicializar
if (!imu.begin(11, 12)) {
    Serial.println("Failed to initialize QMI8658!");
    while (1) {
      delay(100);
    }
  }

 // Usa m/s^2 y dps (opcional, pero agradable)
  imu.setAccelUnit_mps2(true);
  imu.setGyroUnit_dps(true);
  imu.setDisplayPrecision(3);

  Serial.println("QMI8658 initialized.");

 // Estado inicial del juego
  randomSeed((uint32_t)micros());

  dotX = MATRIX_WIDTH  / 2;
  dotY = MATRIX_HEIGHT / 2;

  dotColor    = matrix.Color(DOT_R, DOT_G, DOT_B);
  circleColor = wheel(random(256));

  drawScene();
}

void loop() {
 // Leer acelerómetro
  float ax, ay, az;
  if (imu.readAccelMPS2(ax, ay, az)) {
 // Depurar si es necesario:
 // Serial.print("AX: "); Serial.print(ax);
 // Serial.print(" AY: "); Serial.print(ay);
 // Serial.print(" AZ: "); Serial.println(az);

    updateDotFromTilt(ax, ay);
  }

 // Comprobar colisión con círculo
  bool onCircle = isOnCircle(dotX, dotY);
  if (onCircle && !wasOnCircle) {
 // Solo tocar el círculo: cambiar color + sonido beep
    circleColor = wheel(random(256));
    buzzOnce();
  }
  wasOnCircle = onCircle;

 // Redibujar
  drawScene();

 // Pequeño retraso para no perjudicar demasiado el I2C.
  delay(10);
}