/*
 * Projekt 6: Tilt Circle Game - ESP32-S3 RGB LED Matrix (Waveshare)
 * 
 * Dieses Sketch liest die Neigung vom QMI8658C IMU und bewegt einen Punkt
 * sanft auf der 8×8 RGB LED-Matrix basierend auf der Ausrichtung des Boards.
 * 
 * ▶️ Video-Tutorial:
 * https://youtu.be/JKLuYrRcLMI
 * 
 * 📚⬇️ Ressourcen & Code-Seite:
 * 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> // von Lahav Gahali

 // -------- LED MATRIX EINRICHTUNG --------
#define MATRIX_PIN    14
#define MATRIX_WIDTH  8
#define MATRIX_HEIGHT 8

 // Buzzer-Pin - ändern Sie dies auf Ihr tatsächliches Buzzer-GPIO.
const int BUZZER_PIN = 6; // TODO: Setzen Sie Ihren Buzzer-Pin.

 // Matrix-Helligkeit (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
);

 // -------- IMU EINSTELLUNG --------
QMI8658 imu;

 // -------- SPIELKONFIGURATION --------

 // Wie oft der Punkt sich bewegen darf (ms).
 // Größer = langsameres Bewegung.
const uint16_t MOVE_INTERVAL_MS = 150; // versuchen 120-250

 // Wie viel Neigung (m/s^2) bevor sich der Punkt bewegt.
 // Erhöhe, wenn es sich zu empfindlich anfühlt.
const float ACC_TILT_THRESHOLD = 2.0f; // etwa ~0,2 g

 // Punkt Grundfarbe (RGB)
const uint8_t DOT_R = 255;
const uint8_t DOT_G = 255;
const uint8_t DOT_B = 255;


 // Kreisgeometrie (zentrisch auf 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; // +- Dicke um den Radius

 // -------- SPIELSTATUS --------

 // Punktposition im 8x8-Raster (0..7)
int dotX = 3;
int dotY = 3;

 // Farben (16-Bit NeoMatrix Farben)
uint16_t dotColor;
uint16_t circleColor;

 // Um "gerade berührt Kreis" von "immer noch auf Kreis" zu unterscheiden
bool wasOnCircle = false;

 // Timer zur Begrenzung der Bewegung
unsigned long lastMoveTime = 0;

 // -------- HILFSFUNKTIONEN --------

 // Klassisches NeoPixel-Farbrad (0-255 -> Regenbogen)
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);
  }
}

 // Liegt ein gegebener Pixel ungefähr auf dem Kreis?
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);
}

 // Kreis + Punkt zeichnen
void drawScene() {
  matrix.fillScreen(0);

 // Kreis zeichnen
  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);
      }
    }
  }

 // Punkt zeichnen (oben)
  matrix.drawPixel(dotX, dotY, dotColor);

  matrix.show();
}

 // Einfacher Blockierpiepton (kurz)
void buzzOnce() {
  digitalWrite(BUZZER_PIN, HIGH);
  delay(40);
  digitalWrite(BUZZER_PIN, LOW);
}

 // Verwenden Sie den Beschleunigungssensor, um die Bewegung des Punkts zu bestimmen.
void updateDotFromTilt(float ax, float ay) {
  unsigned long now = millis();
  if (now - lastMoveTime < MOVE_INTERVAL_MS) {
    return; // zu früh, warte
  }

  int dx = 0;
  int dy = 0;

 // Auf diesem Board fühlt sich Y-Neigung wie "links/rechts" auf der Matrix an,
 // und X-Neigung fühlt sich an wie "hoch/runter" → also tauschen wir.

 // --- Horizontale Bewegung von AY (Neigung nach links/rechts) ---
  if (ay > ACC_TILT_THRESHOLD) {
    dx = 1; // neigen Sie nach rechts → bewegen Sie den Punkt nach rechts
  } else if (ay < -ACC_TILT_THRESHOLD) {
    dx = -1; // neigen nach links → Punkt nach links bewegen
  }

 // --- Vertikale Bewegung von AX (Vorwärts-/Rückneigung) ---
 // Das wurde invertiert. Wir drehen die Vorzeichen um:
 // ax > Schwelle = Neigung "vorwärts" (weg) → Punkt nach OBEN bewegen (dy = -1)
 // ax < -Schwelle = Neigung "zurück" (nach)→ Punkt nach UNTEN bewegen (dy = 1)
  if (ax > ACC_TILT_THRESHOLD) {
    dy = -1; // war +1 zuvor
  } else if (ax < -ACC_TILT_THRESHOLD) {
    dy = 1; // war vorher -1
  }

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


 // -------- EINRICHTUNG & SCHLEIFE --------

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

 // Matrix-Initialisierung
  matrix.begin();
  matrix.setBrightness(MATRIX_BRIGHTNESS);
  matrix.fillScreen(0);
  matrix.show();

 // Buzzer-Init
  pinMode(BUZZER_PIN, OUTPUT);
  digitalWrite(BUZZER_PIN, LOW);

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

 // Verwenden Sie m/s^2 und dps (optional, aber schön)
  imu.setAccelUnit_mps2(true);
  imu.setGyroUnit_dps(true);
  imu.setDisplayPrecision(3);

  Serial.println("QMI8658 initialized.");

 // Spielanfangszustand
  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() {
 // Beschleunigungsmesser lesen
  float ax, ay, az;
  if (imu.readAccelMPS2(ax, ay, az)) {
 // Debuggen Sie bei Bedarf:
 // Serial.print("AX: "); Serial.print(ax);
 // Serial.print(" AY: "); Serial.print(ay);
 // Serial.print(" AZ: "); Serial.println(az);

    updateDotFromTilt(ax, ay);
  }

 // Kollision mit dem Kreis überprüfen
  bool onCircle = isOnCircle(dotX, dotY);
  if (onCircle && !wasOnCircle) {
 // Gerade berührter Kreis: Farbe ändern + Piepton
    circleColor = wheel(random(256));
    buzzOnce();
  }
  wasOnCircle = onCircle;

 // Neu zeichnen
  drawScene();

 // Kleine Verzögerung, damit wir I2C nicht zu sehr belasten.
  delay(10);
}