// I shouldn't be doing this now because it's 1 am and there's 2 tests tomorrow
// so why am I doing it now? I don't know.


#define buzzer A0 //P5
#define pinR 3
#define pinG 5
#define pinB 6 //why is it cyan
int timelimit = 10000; //Modify based on how long the buzzer lasts.
int interval = 100;
#define step 5 //keep it this way pls
  int delayed = 10; //timing issue >:(
int sequence[] = {0, 100, 200, 400, 1000, 150, 400, 0, 0}; //size = *2
//400, 200, 1000, 400, 200, 1000, 0, 0, 400, 200, 0};
unsigned long now = millis();

int stageLED = 1;
int stageBuzzer = 0;

// void playnote(int Note); void colorTest(); void buzzerTest();
void setRGB(int red, int green, int blue);
void RGB();
void buzz();

void setup() {
  pinMode(buzzer, OUTPUT);
  pinMode(pinR, OUTPUT);
  pinMode(pinG, OUTPUT);
  pinMode(pinB, OUTPUT);
  Serial.begin(9600);
  delay(2000);
}



void loop() {
  now = millis();
  while ((millis()-now) < timelimit){ //don't want it resetting early
    buzz();
    RGB();
  }
  Serial.println("Done!");
  int stageLED = 1; //failsafe reset stage
  int stageBuzzer = 0;
}

void buzz(){
  bool pass = false;
  // Too lazy to adjust, make sure the 1st note playing is actually the 2nd in sequence.
  for(int i = stageBuzzer; i < (sizeof(sequence)/2.0); i++){ //Determined by Sequence length
    stageBuzzer++;
    if ((millis() - now) > (interval*i)){ //Each tone only outputs at correct time.
    /*
    Serial.println(millis() - now);
    Serial.println(interval*i);
    Serial.print(" Note: "); Serial.println(sequence[i]);
    Serial.print("Buzzer at"); Serial.println(stageBuzzer);*/
    tone(buzzer, sequence[i]); pass = true;}
    delay(interval+10); // To allow each note to play.
    noTone(buzzer); 
    if(i == (sizeof(sequence)/2.0 -1)) {Serial.print("Time taken: "); Serial.println(millis() - now);} //Prints at the last stage to show time elapsed.
    if(pass == true){//Serial.println("Synchronize A"); 
    return(0);} //not exit(0); which stops the entire thing?
    //Nothing must go below return.
    }

}

void setRGB(int red, int green, int blue){
    analogWrite(pinR, red); //simplify it into 1
    analogWrite(pinG, green);
    analogWrite(pinB, blue);
}


void RGB(){ //Old RGB (no millis)
  //Stages: G+ R- B+ G- R+ B-
  setRGB(0, 255, 255);
  int intervalLED = delayed*(255/step); //or 260?
  //delay(intervalLED); //too lazy to compare. if this isn't here, it'd skip the whole thing
  // If time elapsed > sequence benchmark
  //Serial.println(intervalLED);
  //Serial.println(millis()-now);
  
  
  switch (stageLED){ //no need break; because got return(0);
    case 1:
      if((millis() - now) > intervalLED){  
      for(int i = 255; i >= 0; i-= step){
        //Serial.println(step);
        setRGB(0, i, 255);
        delay(delayed);} stageLED = 2; return(0);} //Now: 0, 0, 255
      //Serial.println(millis()-now);
      //Serial.println("Synchronize B");
      
    case 2:
      //Serial.println("Synchronize C"); //Issue: it's skipping these because it's going through it over and over instead of others
      if((millis() - now) > intervalLED*2){
      for(int i = 0; i <= 255; i+= step){
        setRGB(i, 0, 255);
        delay(delayed);} stageLED = 3; return(0);} //Now: 255, 0, 255

    case 3:
      if((millis() - now) > intervalLED*3){
      for(int i = 255; i >= 0; i-= step){
        setRGB(255, 0, i);
        delay(delayed);} stageLED = 4; return(0);} //Now: 255, 0, 0
      
    case 4:
      if((millis() - now) > intervalLED*4){
      for(int i = 0; i <= 255; i+= step){
        setRGB(255, i, 0);
        delay(delayed);} stageLED = 5; return(0);} //Now: 255, 255, 0
      
    case 5:
      if((millis() - now) > intervalLED*5){
      for(int i = 255; i >= 0; i-= step){
        setRGB(i, 255, 0);
        delay(delayed);} stageLED = 6; return(0);} //Now: 0, 255, 0
      
    case 6:
      if((millis() - now) > intervalLED*6){
      for(int i = 0; i <= 255; i+= step){
        setRGB(0, 255, i);
        delay(delayed);} stageLED = 1; return(0);} //Now: 0, 255, 255
      
  }
  //Serial.println(stageLED);
}


/*
void RGB(){ //Old RGB (no millis)
  int step = 5;
  int delayed = 20;
  //Stages: G+ R- B+ G- R+ B-
  setRGB(0, 255, 255);
  for(int i = 255; i >= 0; i-= step){
    setRGB(0, i, 255);
    delay(delayed);} //Now: 0, 0, 255
  for(int i = 0; i <= 255; i+= step){
    setRGB(i, 0, 255);
    delay(delayed);} //Now: 255, 0, 255
  for(int i = 255; i >= 0; i-= step){
    setRGB(255, 0, i);
    delay(delayed);} //Now: 255, 0, 0

  for(int i = 0; i <= 255; i+= step){
    setRGB(255, i, 0);
    delay(delayed);} //Now: 255, 255, 0
  for(int i = 255; i >= 0; i-= step){
    setRGB(i, 255, 0);
    delay(delayed);} //Now: 0, 255, 0
  for(int i = 0; i <= 255; i+= step){
    setRGB(0, 255, i);
    delay(delayed);} //Now: 0, 255, 255
}
*/

/*
void playnote(int Note){
  for (double i = 0; i < (40); i++){
    digitalWrite(buzzer, HIGH); delay(Note);
    digitalWrite(buzzer, LOW); delay(0);
    }
  delay(10);
} //Alternative which I didn't realize was not the correct function
void colorTest(){
  setRGB(0, 0, 0); //on
  delay(500);
  setRGB(255, 0, 0); //cyan
  delay(500);
  setRGB(0, 255, 0); //magenta
  delay(500);
  setRGB(0, 0, 255); //yellow
  delay(500);
  setRGB(255, 255, 0); //blue
  delay(500);
  setRGB(0, 255, 255); //red
  delay(500);
  setRGB(255, 0, 255); //green
  delay(500);}
void buzzerTest(){
    for(int i = 1500; i > 10; i-= 1){ //max (you* can hear) around 15000, you'd only realistically use until 5000
    Serial.println(i);
    tone(buzzer, i);
    delay(interval);
    noTone(buzzer);
    delay(interval);
  }}
*/
// high 20, low 1 = lowwww square thing
//50 no sound