#include "Arduino_LED_Matrix.h"

// Initialize LED Matrix
ArduinoLEDMatrix matrix;

// Pin definitions
const int buttonPins[4] = {2, 3, 4, 5};
const int ledPins[4] = {6, 7, 8, 9};
const int buzzerPin = 10;

// Game variables
int gameSequence[100];
int playerSequence[100];
int gameLevel = 1;
int sequenceLength = 1;
bool gameActive = false;
bool playerTurn = false;
int playerIndex = 0;

// Timing variables
unsigned long lastButtonPress = 0;
unsigned long sequenceStartTime = 0;
const unsigned long buttonDebounce = 200;
const unsigned long playerTimeout = 3000;

// LED Matrix patterns for each color
const uint32_t redPattern[3] = {
  0x3C3C3C3C,
  0x3C3C3C3C,
  0x3C3C3C3C
};

const uint32_t greenPattern[3] = {
  0xC3C3C3C3,
  0xC3C3C3C3,
  0xC3C3C3C3
};

const uint32_t bluePattern[3] = {
  0x0F0F0F0F,
  0x0F0F0F0F,
  0x0F0F0F0F
};

const uint32_t yellowPattern[3] = {
  0xF0F0F0F0,
  0xF0F0F0F0,
  0xF0F0F0F0
};

void setup() {
  Serial.begin(9600);
  
  // Initialize LED Matrix
  matrix.begin();
  
  // Initialize buttons as inputs with pull-up
  for (int i = 0; i < 4; i++) {
    pinMode(buttonPins[i], INPUT_PULLUP);
    pinMode(ledPins[i], OUTPUT);
    digitalWrite(ledPins[i], LOW);
  }
  
  // Initialize buzzer
  pinMode(buzzerPin, OUTPUT);
  
  // Seed random number generator
  randomSeed(analogRead(A0));
  
  // Show welcome screen
  showWelcomeScreen();
  delay(2000);
  
  // Start first game
  startNewGame();
}

void loop() {
  if (gameActive) {
    if (!playerTurn) {
      // Show sequence to player
      showSequence();
      playerTurn = true;
      playerIndex = 0;
      sequenceStartTime = millis();
    } else {
      // Wait for player input
      checkPlayerInput();
      
      // Check for timeout
      if (millis() - sequenceStartTime > playerTimeout * sequenceLength) {
        gameOver();
      }
    }
  } else {
    // Wait for button press to start new game
    for (int i = 0; i < 4; i++) {
      if (digitalRead(buttonPins[i]) == LOW) {
        delay(buttonDebounce);
        if (digitalRead(buttonPins[i]) == LOW) {
          startNewGame();
          break;
        }
      }
    }
  }
}

void startNewGame() {
  gameLevel = 1;
  sequenceLength = 1;
  gameActive = true;
  playerTurn = false;
  
  // Generate first sequence
  for (int i = 0; i < sequenceLength; i++) {
    gameSequence[i] = random(0, 4);
  }
  
  showLevel();
  delay(1000);
}

void showSequence() {
  for (int i = 0; i < sequenceLength; i++) {
    // Show color on LED Matrix
    showColor(gameSequence[i]);
    playTone(gameSequence[i]);
    delay(600);
    
    // Clear display
    matrix.clear();
    delay(200);
  }
}

void showColor(int colorIndex) {
  // Turn on corresponding LED
  digitalWrite(ledPins[colorIndex], HIGH);
  
  // Show pattern on LED Matrix
  switch (colorIndex) {
    case 0: // Red
      matrix.loadFrame(redPattern);
      break;
    case 1: // Green
      matrix.loadFrame(greenPattern);
      break;
    case 2: // Blue
      matrix.loadFrame(bluePattern);
      break;
    case 3: // Yellow
      matrix.loadFrame(yellowPattern);
      break;
  }
  
  delay(400);
  digitalWrite(ledPins[colorIndex], LOW);
}

void playTone(int colorIndex) {
  int frequencies[4] = {262, 330, 392, 523}; // C, E, G, C
  tone(buzzerPin, frequencies[colorIndex], 400);
}

void checkPlayerInput() {
  for (int i = 0; i < 4; i++) {
    if (digitalRead(buttonPins[i]) == LOW && 
        millis() - lastButtonPress > buttonDebounce) {
      
      lastButtonPress = millis();
      
      // Show player's choice
      showColor(i);
      
      // Check if correct
      if (i == gameSequence[playerIndex]) {
        playerIndex++;
        
        // Check if sequence complete
        if (playerIndex >= sequenceLength) {
          // Level complete!
          levelComplete();
        }
      } else {
        // Wrong button - game over
        gameOver();
      }
      
      break;
    }
  }
}

void levelComplete() {
  // Show success animation
  showSuccessAnimation();
  
  // Increase difficulty
  gameLevel++;
  sequenceLength++;
  
  // Add new color to sequence
  gameSequence[sequenceLength - 1] = random(0, 4);
  
  // Reset for next level
  playerTurn = false;
  playerIndex = 0;
  
  showLevel();
  delay(1500);
}

void gameOver() {
  gameActive = false;
  
  // Show game over animation
  showGameOverAnimation();
  
  // Play game over sound
  for (int i = 0; i < 3; i++) {
    tone(buzzerPin, 200, 200);
    delay(300);
  }
  
  // Show final score
  showScore();
  delay(3000);
  
  // Show restart message
  showRestartMessage();
}

void showWelcomeScreen() {
  const uint32_t welcomeFrame[3] = {
    0x19297A5E,
    0x297A5E19,
    0x7A5E1929
  };
  
  matrix.loadFrame(welcomeFrame);
}

void showLevel() {
  // Create level display pattern
  uint32_t levelFrame[3] = {0, 0, 0};
  
  // Simple level indicator (dots)
  for (int i = 0; i < min(gameLevel, 12); i++) {
    int row = i / 4;
    int col = i % 4;
    levelFrame[row] |= (1UL << (31 - col * 8));
  }
  
  matrix.loadFrame(levelFrame);
}

void showSuccessAnimation() {
  // Animated success pattern
  const uint32_t successFrames[4][3] = {
    {0x00000000, 0x00180000, 0x00000000},
    {0x00000000, 0x003C0000, 0x00000000},
    {0x00180000, 0x007E0000, 0x00180000},
    {0x003C0000, 0x00FF0000, 0x003C0000}
  };
  
  for (int frame = 0; frame < 4; frame++) {
    matrix.loadFrame(successFrames[frame]);
    tone(buzzerPin, 523 + frame * 100, 150);
    delay(200);
  }
  
  delay(500);
  matrix.clear();
}

void showGameOverAnimation() {
  // Game over X pattern
  const uint32_t gameOverFrame[3] = {
    0x81424281,
    0x42244224,
    0x81424281
  };
  
  for (int i = 0; i < 5; i++) {
    matrix.loadFrame(gameOverFrame);
    delay(200);
    matrix.clear();
    delay(200);
  }
}

void showScore() {
  // Display final score
  Serial.print("Game Over! Final Level: ");
  Serial.println(gameLevel - 1);
  
  // Simple score display on matrix
  uint32_t scoreFrame[3] = {0, 0, 0};
  
  // Show score as binary pattern
  int score = gameLevel - 1;
  for (int i = 0; i < 8 && i < score; i++) {
    scoreFrame[0] |= (1UL << (31 - i * 4));
  }
  
  matrix.loadFrame(scoreFrame);
}

void showRestartMessage() {
  // Blinking pattern to indicate restart
  const uint32_t restartFrame[3] = {
    0xFFFFFFFF,
    0x00000000,
    0xFFFFFFFF
  };
  
  for (int i = 0; i < 6; i++) {
    matrix.loadFrame(restartFrame);
    delay(300);
    matrix.clear();
    delay(300);
  }
}

// Advanced audio using DAC
void playMelody(int colorIndex) {
  int melodies[4][4] = {
    {262, 294, 330, 349}, // Red - C major scale
    {330, 370, 415, 466}, // Green - E major scale  
    {392, 440, 494, 523}, // Blue - G major scale
    {523, 587, 659, 698}  // Yellow - High C major scale
  };
  
  for (int i = 0; i < 4; i++) {
    analogWrite(DAC, map(sin(millis() * melodies[colorIndex][i] / 1000.0) * 127 + 127, 0, 255, 0, 255));
    delay(100);
  }
}

// High score system using EEPROM
#include 

int highScore = 0;
const int EEPROM_ADDRESS = 0;

void loadHighScore() {
  highScore = EEPROM.read(EEPROM_ADDRESS);
  if (highScore == 255) highScore = 0; // First time
}

void saveHighScore() {
  if (gameLevel - 1 > highScore) {
    highScore = gameLevel - 1;
    EEPROM.write(EEPROM_ADDRESS, highScore);
    showNewRecord();
  }
}

void showNewRecord() {
  // Special animation for new record
  for (int i = 0; i < 10; i++) {
    matrix.loadFrame(successFrames[i % 4]);
    tone(buzzerPin, 800 + i * 50, 100);
    delay(150);
  }
}

#include 
#include 

const char* ssid = "YourWiFi";
const char* password = "YourPassword";

void setupWiFi() {
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }
  Serial.println("WiFi connected!");
}

void uploadScore(int score) {
  if (WiFi.status() == WL_CONNECTED) {
    HTTPClient http;
    http.begin("http://yourserver.com/api/scores");
    http.addHeader("Content-Type", "application/json");
    
    String payload = "{\"score\":" + String(score) + "}";
    int httpResponseCode = http.POST(payload);
    
    if (httpResponseCode > 0) {
      Serial.println("Score uploaded successfully!");
    }
    
    http.end();
  }
}