const unsigned long globalDuration = 120000; // Global duration for all sequences in milliseconds

const int pins1[] = {2, 3, 2, 4, 5, 6, 2}; // Define pin sequence for sequence 1
const unsigned long timings1[] = {0, 60000, 70000, 80000, 90000, 100000, 110000}; // Timing for sequence 1

const int pins2[] = {9, 7, 8, 9}; // Define pin sequence for sequence 2
const unsigned long timings2[] = {0, 80000, 90000, 100000}; // Timing for sequence 2

const int buttonPin = 10; // Button connected to pin 10

bool autoRestart = true; // Set to true to enable automatic looping without button press
bool logging = true; // Enable or disable logging

struct Sequence {
  const unsigned long* timings;
  const int* pins;
  int stepCount;
  int currentStep;
  bool isComplete;

  Sequence(const unsigned long* t, const int* p, int sc) : timings(t), pins(p), stepCount(sc), currentStep(0), isComplete(false) {}
};

bool sequencesRunning = false;

// Define the sequences
Sequence sequences[] = {
  Sequence(timings1, pins1, sizeof(timings1) / sizeof(timings1[0])),
  Sequence(timings2, pins2, sizeof(timings2) / sizeof(timings2[0]))
};

unsigned long startTime;

void setup() {
  Serial.begin(9600);
  pinMode(buttonPin, INPUT_PULLUP); // Button with pull-up resistor

  // Initialize pins as outputs and set to LOW, then test each LED for half a second
  for (int i = 2; i <= 9; i++) {
    pinMode(i, OUTPUT);
    digitalWrite(i, HIGH); // Turn on LED
    delay(500);            // Wait to see LED light up
    digitalWrite(i, LOW);   // Turn off LED
  }

  Serial.println("LED test complete. Press the button to start the sequences.");
}

void loop() {
  static bool lastButtonState = HIGH;
  bool currentButtonState = digitalRead(buttonPin);

  // Edge detection for button press
  if (lastButtonState == HIGH && currentButtonState == LOW) {
    delay(50); // Debounce delay
    while (digitalRead(buttonPin) == LOW); // Wait for button release
    delay(50); // Additional debounce delay

    sequencesRunning = !sequencesRunning; // Toggle the running state of the sequences

    if (sequencesRunning) {
      startSequences();
    } else {
      Serial.println("Sequences stopped by button press.");
      resetSequences();
    }
  }
  lastButtonState = currentButtonState;

  if (sequencesRunning) {
    runSequences();
  }
}

void startSequences() {
  startTime = millis();
  sequencesRunning = true;
  Serial.println("Sequences started.");

  for (Sequence &seq : sequences) {
    seq.currentStep = -1;
    seq.isComplete = false;
  }
}

void runSequences() {
  unsigned long currentTime = millis();
  unsigned long elapsedTime = currentTime - startTime;

  if (elapsedTime < globalDuration) {
    for (int i = 0; i < sizeof(sequences) / sizeof(Sequence); ++i) {
      if (!sequences[i].isComplete) {
        updateSequence(i, sequences[i], elapsedTime);
      }
    }
  } else if (autoRestart) {
    startSequences(); // Restart sequences
    startTime = millis(); // Reset the start time
  } else {
    Serial.println("Global duration reached. Sequences stopped.");
    sequencesRunning = false;
    resetSequences();
  }
}

void updateSequence(int sequenceNumber, Sequence& seq, unsigned long elapsedTime) {
  unsigned long currentTiming = seq.currentStep + 1 < seq.stepCount ? seq.timings[seq.currentStep + 1] : globalDuration;
  while (!seq.isComplete && elapsedTime >= currentTiming) {
    // Turn off the previous pin
    if (seq.currentStep >= 0 && seq.pins[seq.currentStep] > 0) {
      digitalWrite(seq.pins[seq.currentStep], LOW);
    }

    // Advance to the next step
    seq.currentStep++;

    // Log action
    if (logging) {
      long deltaError = elapsedTime - currentTiming;
      logSequenceAction(sequenceNumber, seq.currentStep, seq.pins[seq.currentStep], elapsedTime, deltaError);
    }

    // Turn on the next pin if it's not the end of the sequence
    if (seq.currentStep < seq.stepCount && seq.pins[seq.currentStep] >= 0) {
      digitalWrite(seq.pins[seq.currentStep], HIGH);
    }

    // get the next duration:
    currentTiming = seq.currentStep + 1 < seq.stepCount ? seq.timings[seq.currentStep + 1] : globalDuration;

    // Check if the sequence is complete
    if (seq.currentStep >= seq.stepCount) {
      seq.isComplete = true;
      if (logging) {
        Serial.print("Sequence ");
        Serial.print(sequenceNumber);
        Serial.println(" Complete!");
      }
    }
  }
}

void logSequenceAction(int sequenceNumber, int step, int pin, unsigned long time, long deltaError) {
  Serial.print("Seq ");
  Serial.print(sequenceNumber + 1);
  Serial.print(" | Step ");
  Serial.print(step + 1);
  Serial.print(" | Pin ");
  Serial.print(pin);
  Serial.print(" | Time (start) ");
  Serial.print(time);
  Serial.print(" ms | Delta Error ");
  Serial.print(deltaError);
  Serial.println(" ms");
}

void resetSequences() {
  for (Sequence &seq : sequences) {
    for (int pinIndex = 0; pinIndex < seq.stepCount; pinIndex++) {
      if (seq.pins[pinIndex] >= 0) {
        digitalWrite(seq.pins[pinIndex], LOW);
      }
    }
    seq.currentStep = 0;
    seq.isComplete = false;
  }
  sequencesRunning = false;
}