#include <EEPROM.h>

#define MODE_EEPROM_ADDR 10

// Init Pins
const uint8_t buttonPins[] = {12, 11, 10, 9, 7, 6, 5, 4};
const uint8_t ledPins[] = {A0, A1, 2, 3, A4, A5};
const uint8_t led4Pin = A2;
const int numButton = sizeof(buttonPins) / sizeof(buttonPins[0]);
const int numLed = sizeof(ledPins) / sizeof(ledPins[0]);

int buttonRead[] = {LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW};

// Init Mode Button
int mode = 0; // Mode 0  & 1
int modeButtonLastState = LOW;
int modeButtonCurrentState;
int modeButtonCounter = 0;

// Init Animation Button
int animButtonLastState[] = {LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW};
int animButtonCurrentState[] = {LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW};
int animMode[] = {0,0,0,0,0,0,0,0}; // 0 = Off, 1 = On
int animButtonCounter = 0;
int animButtonLastPressed;
uint32_t animCurrentMillis;
bool isAnim = false;

unsigned long animPreviousMillis = 0;
uint32_t animBatch = 0;
unsigned long delayMillis = 10000;

void setup() {
  Serial.begin(9600);
  for (uint8_t i = 0; i < numButton; i++) {
    pinMode(buttonPins[i], INPUT);
  }
  for (uint8_t i = 0; i < numLed; i++) {
    pinMode(ledPins[i], OUTPUT);
  }
  pinMode(led4Pin, OUTPUT);

  mode = readIntFromEEPROM(MODE_EEPROM_ADDR);
  if(mode == -1)  {mode = 0;} // init
  Serial.println(mode);

}

void loop() {
  for (uint8_t i = 0; i < numButton; i++) {
    buttonRead[i] = digitalRead(buttonPins[i]);
  }

  // modeButtonFunction(3);
  
  // int manualButton[] = {buttonRead[5],buttonRead[6],buttonRead[7]};
  // manualButtonFunction(manualButton);

  buttonFunction(buttonRead);
  
  // led1.Update();
  // led4Function();
  // for(int i = 0; i < numLed; i++){
  //   digitalWrite(ledPins[i], HIGH);
  // }
}

void led4Function() {
  if(isAnim) {
    digitalWrite(led4Pin, HIGH);
  } else {
    digitalWrite(led4Pin, LOW);
  }
}

void buttonFunction(int button[]) {
  for(uint8_t i = 0; i < numButton; i++) {
    animButtonCurrentState[i] = button[i];
    
    if(animButtonLastState[i] == HIGH && animButtonCurrentState[i] == LOW) {
      animPreviousMillis = millis();
      animBatch = 0;
      modeButtonCounter = 0;

      animMode[i] = !animMode[i];
      if(animButtonCounter > 1) {
        animButtonCounter = 0;
      }

      if(millis() - animCurrentMillis < 100) {
        animButtonCounter += 1;
      } else {
        animButtonCounter = 0;
      }

      // Turn off other buttons
      if(animButtonCounter == 0) {
        for(uint8_t y = 0; y < numButton; y++) {
          if(y == i) {continue;}
          animMode[y] = 0;
        }
      }

      // Serial.println("------START------");
      for(int j = 0; j < numButton; j++) {
        Serial.print(animMode[j]);
        Serial.print(", ");
      }
      Serial.println("");
      // Serial.println("------END------");
      animCurrentMillis = millis();
      turnOffAllLeds();
    }
    animButtonLastState[i] = animButtonCurrentState[i];
  }

  // Button Combinations
  int buttonArray[] = {animMode[0], animMode[1], animMode[2], animMode[3],
                        animMode[4], animMode[5], animMode[6], animMode[7]};
  int t0[] = {0,0,0,0,0,0,0,0}; // Off
  int t1[] = {0,0,0,0,1,0,0,1};
  int t2[] = {0,0,0,0,0,0,0,1};
  int t3[] = {1,0,0,0,0,0,0,1};
  int t4[] = {1,0,0,0,0,0,0,0};
  int t5[] = {1,1,0,0,0,0,0,0};
  int t6[] = {0,1,0,0,0,0,0,0};
  int t7[] = {0,0,0,1,0,0,0,1};
  int t8[] = {0,0,0,0,1,0,0,0};
  int t9[] = {0,0,0,0,1,1,0,0};
  int t10[] = {0,0,0,0,0,1,0,0};
  int t11[] = {0,0,0,0,0,1,1,0};
  int tmode[] = {0,0,0,0,0,0,1,0};
  int tplus[] = {0,1,0,0,0,0,1,0};
  int tmin[] = {0,0,1,0,0,0,1,0};
  int ta[] = {1,0,0,0,1,0,0,0};
  int tb[] = {0,0,0,1,0,0,0,0};
  int tc[] = {0,0,0,0,1,0,0,1};
  int td[] = {1,0,0,0,0,1,0,0};
  int te[] = {0,0,1,0,0,0,0,0};
  int tf[] = {0,1,0,0,0,1,0,0};
  int allT[] = {t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,
                tmode,tplus,tmin,ta,tb,tc,td,te,tf};
  int animT[] = {t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11};
  int utilT[] = {tmode,tplus,tmin};
  int manualT[] = {ta,tb,tc,td,te,tf};
  const int numAnimT = sizeof(animT) / sizeof(animT[0]);
  const int numUtilT = sizeof(utilT) / sizeof(utilT[0]);
  const int numManualT = sizeof(manualT) / sizeof(manualT[0]);

  // If Animation is Off
  if(compareArray(buttonArray, t0)) {
    isAnim = false;
  } else {
    isAnim = true;
  }
  
  for(uint8_t i = 0; i < numAnimT; i++) {
    if(compareArray(buttonArray, animT[i])) {
      animButtonMapping(i);
    }
  }

  for(uint8_t i = 0; i < numUtilT; i++) {
    if(compareArray(buttonArray, utilT[i])) {
      utilButtonMapping(i);
    }
  }

  for(uint8_t i = 0; i < numManualT; i++) {
    if(compareArray(buttonArray, manualT[i])) {
      manualButtonMapping(i);
    }
  }
}

void animButtonMapping(int t) {
  if(mode == 0) {
    if(t == 0) {anim1();}
  //   if(anim == 1) {anim2();}
  //   if(anim == 2) {anim3();}
  //   if(anim == 3) {anim4();}
  //   if(anim == 4) {anim5();}
  //   if(anim == 5) {anim6();}
  //   if(anim == 6) {anim7();}
  //   if(anim == 7) {anim8();}
  //   if(anim == 8) {anim9();}
  //   if(anim == 9) {anim10();}
  } else {
  //   if(anim == 0) {anim11();}
  //   if(anim == 1) {anim12();}
  //   if(anim == 2) {anim13();}
  //   if(anim == 3) {anim14();}
  //   if(anim == 4) {anim15();}
  //   if(anim == 5) {anim16();}
  //   if(anim == 6) {anim17();}
  //   if(anim == 7) {anim18();}
  //   if(anim == 8) {anim19();}
  //   if(anim == 9) {anim20();}
  }
}

void utilButtonMapping(int t) {
  if(t == 0) {
    if(modeButtonCounter == 0) {
      animBatch = 0;
      mode = !mode;
      writeIntIntoEEPROM(MODE_EEPROM_ADDR, mode); // Save Mode to EEPROM
      Serial.println(mode);
      modeButtonCounter = 1;
    }
  }
}

void manualButtonMapping(int t) {

}


// Animation
void anim1() {
  // Seperti delay pada umumnya namun tidak memblock program lain
  // Tambah animasi dengan menambah else if animBatch +1
  if(animBatch == 0) {
    digitalWrite(ledPins[0], HIGH);	  
    delayMillis = 500;
  } else if(animBatch == 1) {
    digitalWrite(ledPins[0], LOW);	  
    delayMillis = 500;
  } else if(animBatch == 2) {
    digitalWrite(ledPins[1], HIGH);	  
    delayMillis = 500;
  } else if(animBatch == 3) {
    digitalWrite(ledPins[1], LOW);	  
    delayMillis = 500;
  } else if(animBatch == 4) {
    digitalWrite(ledPins[2], HIGH);	  
    delayMillis = 500;
  } else if(animBatch == 5) {
    digitalWrite(ledPins[2], LOW);	  
    delayMillis = 0; // Delay terakhir 0
  }

  // Millis function logic. Set parameter to max animBatch
  animMillisFunction(5);
}

// ----------------------------------

// Utility Function
void animMillisFunction(int maxBatch) {
  if(millis() - animPreviousMillis > delayMillis) {
    animPreviousMillis = millis();
    // animBatch >= di sesuaikan dengan jumlah maksimal batch animasi
    if(animBatch >= maxBatch) {
      isAnim = false;
      resetAnim();
    } else {
      animBatch += 1;
    }
  }
}

void resetAnim() {
  animButtonCounter = 0;
  for(uint8_t y = 0; y < 4; y++) {
    animMode[y] = 0;
  }
}

void turnOffAllLeds() {
  for(uint8_t i = 0; i < numLed; i++) {
    digitalWrite(ledPins[i], LOW);
  }
}

boolean compareArray(int a[], int b[]) {
  boolean res = true;
  for (int i = 0;  i < numButton; i++) {
    if( a[i] != b[i] ) {
      // Serial.println("not equal");
      //set your boolean flag here
      res = false;
      break;
    }
  }
  return res;
}

void writeIntIntoEEPROM(int address, int number) { 
  EEPROM.write(address, number >> 8);
  EEPROM.write(address + 1, number & 0xFF);
}

int readIntFromEEPROM(int address) {
  return (EEPROM.read(address) << 8) + EEPROM.read(address + 1);
}