#include <Arduino.h>

// Pin Definitions for LEDs (simulating motors)
#define MOTOR1_EN_PIN 9    // LED 1
#define MOTOR2_EN_PIN 8    // LED 2
#define MOTOR3_EN_PIN 7    // LED 3
#define MOTOR4_EN_PIN 6    // LED 4
#define MOTOR5_EN_PIN 5    // LED 5
#define MOTOR6_EN_PIN 4    // LED 6

// Pin Definitions for Buttons
#define BUTTON1_PIN  2    // Program selection button (A/B/C/D/E)
#define BUTTON2_PIN  3    // LED selection button (1-6)

// Program modes
#define PROGRAM_A  1
#define PROGRAM_B  2
#define PROGRAM_C  3
#define PROGRAM_D  4
#define PROGRAM_E  5

// LED selection
#define MOTOR_1    1
#define MOTOR_2    2
#define MOTOR_3    3
#define MOTOR_4    4
#define MOTOR_5    5
#define MOTOR_6    6

// Timing Variables
unsigned long LEDStartTime = 0;
unsigned long LEDStopTime = 0;
unsigned long LEDInterval = 10000;  // Default running time (Program A)
unsigned long stopInterval = 5000;  // Default stop time (Program A)
bool LEDRunning = false;             // Flag to track LED state

// Flags to be set by ISRs
volatile bool changeProgramFlag = false;
volatile bool changeLEDFlag = false;

// Debounce time for button press
#define DEBOUNCE_TIME 200

// Program tracking
volatile int currentProgram = PROGRAM_A;  // Default to Program A
volatile int currentLED = MOTOR_1;        // Default to LED 1

// Function to handle program change
void changeProgram() {
  static unsigned long lastInterruptTime = 0;
  unsigned long interruptTime = millis();
  // Debounce check
  if (interruptTime - lastInterruptTime > DEBOUNCE_TIME) {
    // Switch program and reset LED timings accordingly
    currentProgram = (currentProgram == PROGRAM_E) ? PROGRAM_A : currentProgram + 1;
    Serial.print("Program selected: ");
    if (currentProgram == PROGRAM_A) Serial.println("A");
    else if (currentProgram == PROGRAM_B) Serial.println("B");
    else if (currentProgram == PROGRAM_C) Serial.println("C");
    else if (currentProgram == PROGRAM_D) Serial.println("D");
    else if (currentProgram == PROGRAM_E) Serial.println("E");

    // Adjust timing based on the selected program
    switch (currentProgram) {
      case PROGRAM_A: LEDInterval = 10000; stopInterval = 5000; break;
      case PROGRAM_B: LEDInterval = 8000; stopInterval = 12000; break;
      case PROGRAM_C: LEDInterval = 13000; stopInterval = 15000; break;
      case PROGRAM_D: LEDInterval = 9000; stopInterval = 14000; break;
      case PROGRAM_E: 
        LEDInterval = 0; stopInterval = 0; // All LEDs stop
        digitalWrite(MOTOR1_EN_PIN, LOW);
         digitalWrite(MOTOR2_EN_PIN, LOW);
          digitalWrite(MOTOR3_EN_PIN, LOW);
           digitalWrite(MOTOR4_EN_PIN, LOW);
            digitalWrite(MOTOR5_EN_PIN, LOW);
             digitalWrite(MOTOR6_EN_PIN, LOW);
        break;
    }

    // Reset LED timing when the program is switched
    LEDStartTime = millis();
    LEDStopTime = LEDStartTime + stopInterval;  // Reset stop interval
    LEDRunning = false;  // Ensure the LED stops before switching program
    lastInterruptTime = interruptTime;
  }
}

// Function to handle LED change
void changeLED() {
  static unsigned long lastInterruptTime = 0;
  unsigned long interruptTime = millis();
  // Debounce check
  if (interruptTime - lastInterruptTime > DEBOUNCE_TIME) {
    // Stop the current LED immediately before switching
    stopLED(currentLED);

    // Switch LED immediately when button is pressed
    currentLED = (currentLED == MOTOR_6) ? MOTOR_1 : currentLED + 1;
    Serial.print("LED switched to: ");
    Serial.println(currentLED);

    lastInterruptTime = interruptTime;

    // Reset LED timing when the LED is switched
    LEDStartTime = millis();
    LEDStopTime = LEDStartTime + stopInterval;  // Reset stop interval
    LEDRunning = false;  // Stop LED before switching
  }
}

// Function to start an LED
void startLED(int LED) {
  switch (LED) {
    case MOTOR_1: digitalWrite(MOTOR1_EN_PIN, HIGH); break;
    case MOTOR_2: digitalWrite(MOTOR2_EN_PIN, HIGH); break;
    case MOTOR_3: digitalWrite(MOTOR3_EN_PIN, HIGH); break;
    case MOTOR_4: digitalWrite(MOTOR4_EN_PIN, HIGH); break;
    case MOTOR_5: digitalWrite(MOTOR5_EN_PIN, HIGH); break;
    case MOTOR_6: digitalWrite(MOTOR6_EN_PIN, HIGH); break;
  }
  Serial.print("LED ");
  Serial.print(LED);
  Serial.println(" started");
}

// Function to stop an LED
void stopLED(int LED) {
  switch (LED) {
    case MOTOR_1: digitalWrite(MOTOR1_EN_PIN, LOW); break;
    case MOTOR_2: digitalWrite(MOTOR2_EN_PIN, LOW); break;
    case MOTOR_3: digitalWrite(MOTOR3_EN_PIN, LOW); break;
    case MOTOR_4: digitalWrite(MOTOR4_EN_PIN, LOW); break;
    case MOTOR_5: digitalWrite(MOTOR5_EN_PIN, LOW); break;
    case MOTOR_6: digitalWrite(MOTOR6_EN_PIN, LOW); break;
  }
  Serial.print("LED ");
  Serial.print(LED);
  Serial.println(" stopped");
}

void setup() {
  Serial.begin(9600);

  // Pin Mode Setup
  pinMode(BUTTON1_PIN, INPUT_PULLUP);
  pinMode(BUTTON2_PIN, INPUT_PULLUP);
  pinMode(MOTOR1_EN_PIN, OUTPUT);
  pinMode(MOTOR2_EN_PIN, OUTPUT);
  pinMode(MOTOR3_EN_PIN, OUTPUT);
  pinMode(MOTOR4_EN_PIN, OUTPUT);
  pinMode(MOTOR5_EN_PIN, OUTPUT);
  pinMode(MOTOR6_EN_PIN, OUTPUT);

  // Attach interrupts for buttons
  attachInterrupt(digitalPinToInterrupt(BUTTON1_PIN), []{ changeProgramFlag = true; }, FALLING);
  attachInterrupt(digitalPinToInterrupt(BUTTON2_PIN), []{ changeLEDFlag = true; }, FALLING);

  // Start Program A by default
  startLED(currentLED);
}

void loop() {
  unsigned long currentMillis = millis();

  // Handle program change if needed
  if (changeProgramFlag) {
    changeProgram();
    changeProgramFlag = false;  // Reset flag
  }

  // Handle LED change if needed
  if (changeLEDFlag) {
    changeLED();
    changeLEDFlag = false;  // Reset flag
  }

  // Handle LED timing (start, stop based on program)
  if (LEDRunning) {
    unsigned long elapsedRunTime = currentMillis - LEDStartTime;

    if (elapsedRunTime >= LEDInterval) {
      stopLED(currentLED);
      LEDRunning = false;
      LEDStopTime = currentMillis;  // Track when LED stops
    }

    // Print running time
    Serial.print("LED ");
    Serial.print(currentLED);
    Serial.print(" is running. Elapsed time: ");
    Serial.println(elapsedRunTime / 1000);  // Convert to seconds
  }

  // Handle stop interval and restart LED if time has passed
  if (!LEDRunning) {
    unsigned long elapsedStopTime = currentMillis - LEDStopTime;

    if (elapsedStopTime < stopInterval) {
      Serial.print("LED ");
      Serial.print(currentLED);
      Serial.print(" is stopped. Elapsed stop time: ");
      Serial.println(elapsedStopTime / 1000);
    }

    if (elapsedStopTime >= stopInterval) {
      if (currentProgram != PROGRAM_E) {
        startLED(currentLED);
        LEDStartTime = currentMillis;
        LEDRunning = true;
      }
    }
  }
}