bool lockLED1State = false;
bool lockLED2State = false;
bool lockLED3State = false;
bool lockLED4State = false;

uint8_t spinTime = 50;

uint8_t searchPin = 2;
uint8_t searchLED = 3;

uint8_t slewPin1 = 4;
uint8_t slewPin2 = 5;
uint8_t slewPin3 = 6;
uint8_t slewPin4 = 7;

uint8_t slewLED1 = 8;
uint8_t slewLED2 = 9;
uint8_t slewLED3 = 10;
uint8_t slewLED4 = 11;

uint8_t lockPin1 = 12;
uint8_t lockPin2 = 13;
uint8_t lockPin3 = 22;
uint8_t lockPin4 = 23;

uint8_t lockLED1 = 24;
uint8_t lockLED2 = 25;
uint8_t lockLED3 = 26;
uint8_t lockLED4 = 27;

uint8_t nullToggle1 = 28;
uint8_t nullToggle2 = 29;
uint8_t nullToggle3 = 30;
uint8_t nullToggle4 = 31;

uint8_t nullLED1 = 32;
uint8_t nullLED2 = 33;
uint8_t nullLED3 = 34;
uint8_t nullLED4 = 35;

  int searchPinState;
  int searchLEDState;
  int slewPin1State;
  int slewPin2State;
  int slewPin3State;
  int slewPin4State;
  int slewLED1State;
  int slewLED2State;
  int slewLED3State;
  int slewLED4State;
  int lockPin1State;
  int lockPin2State;
  int lockPin3State;
  int lockPin4State;
  int nullToggle1State;
  int nullToggle2State;
  int nullToggle3State;
  int nullToggle4State;
  int nullLED1State;
  int nullLED2State;
  int nullLED3State;
  int nullLED4State;
  int rebootPinState;

  int lockPin1Reading;
  int lockPin2Reading;
  int lockPin3Reading;
  int lockPin4Reading;

uint8_t seg1A = 36;
uint8_t seg1B = 37;
uint8_t seg1C = 38;
uint8_t seg1D = 39;
uint8_t seg1E = 40;
uint8_t seg1F = 41;
uint8_t seg1G = 42;

uint8_t seg2A = 43;
uint8_t seg2B = 44;
uint8_t seg2C = 45;
uint8_t seg2D = 46;
uint8_t seg2E = 47;
uint8_t seg2F = 48;
uint8_t seg2G = 49;

uint8_t seg3A = 50;
uint8_t seg3B = 51;
uint8_t seg3C = 52;
uint8_t seg3D = 53;
uint8_t seg3E = A2;
uint8_t seg3F = A3;
uint8_t seg3G = A4;

uint8_t seg4A = A5;
uint8_t seg4B = A6;
uint8_t seg4C = A7;
uint8_t seg4D = A8;
uint8_t seg4E = A9;
uint8_t seg4F = A10;
uint8_t seg4G = A11;

uint8_t rebootPin = A12;

int debounce = 50;

uint8_t i;

//randomSeed(analogRead(0));

void spin1() {
  for(i=1; i < 5; i++) {
    digitalWrite(seg1A, HIGH);
    delay(spinTime);
    digitalWrite(seg1A, LOW);
    digitalWrite(seg1B, HIGH);
    delay(spinTime);
    digitalWrite(seg1B, LOW);
    digitalWrite(seg1C, HIGH);
    delay(spinTime);
    digitalWrite(seg1C, LOW);
    digitalWrite(seg1D, HIGH);
    delay(spinTime);
    digitalWrite(seg1D, LOW);
    digitalWrite(seg1E, HIGH);
    delay(spinTime);
    digitalWrite(seg1E, LOW);
    digitalWrite(seg1F, HIGH);
    delay(spinTime);
    digitalWrite(seg1F, LOW);
  }
}

void spin2() {
  for(i=1; i < 5; i++) {
    digitalWrite(seg2A, HIGH);
    delay(spinTime);
    digitalWrite(seg2A, LOW);
    digitalWrite(seg2B, HIGH);
    delay(spinTime);
    digitalWrite(seg2B, LOW);
    digitalWrite(seg2C, HIGH);
    delay(spinTime);
    digitalWrite(seg2C, LOW);
    digitalWrite(seg2D, HIGH);
    delay(spinTime);
    digitalWrite(seg2D, LOW);
    digitalWrite(seg2E, HIGH);
    delay(spinTime);
    digitalWrite(seg2E, LOW);
    digitalWrite(seg2F, HIGH);
    delay(spinTime);
    digitalWrite(seg2F, LOW);
  }
}

void spin3() {
  for(i=1; i < 5; i++) {
    digitalWrite(seg3A, HIGH);
    delay(spinTime);
    digitalWrite(seg3A, LOW);
    digitalWrite(seg3B, HIGH);
    delay(spinTime);
    digitalWrite(seg3B, LOW);
    digitalWrite(seg3C, HIGH);
    delay(spinTime);
    digitalWrite(seg3C, LOW);
    digitalWrite(seg3D, HIGH);
    delay(spinTime);
    digitalWrite(seg3D, LOW);
    digitalWrite(seg3E, HIGH);
    delay(spinTime);
    digitalWrite(seg3E, LOW);
    digitalWrite(seg3F, HIGH);
    delay(spinTime);
    digitalWrite(seg3F, LOW);
  }
}

void spin4() {
  for(i=1; i < 5; i++) {
    digitalWrite(seg4A, HIGH);
    delay(spinTime);
    digitalWrite(seg4A, LOW);
    digitalWrite(seg4B, HIGH);
    delay(spinTime);
    digitalWrite(seg4B, LOW);
    digitalWrite(seg4C, HIGH);
    delay(spinTime);
    digitalWrite(seg4C, LOW);
    digitalWrite(seg4D, HIGH);
    delay(spinTime);
    digitalWrite(seg4D, LOW);
    digitalWrite(seg4E, HIGH);
    delay(spinTime);
    digitalWrite(seg4E, LOW);
    digitalWrite(seg4F, HIGH);
    delay(spinTime);
    digitalWrite(seg4F, LOW);
  }
}

void dieRoll1() {
  spin1();
  randomSeed(analogRead(0));
  uint8_t dieValue1 = random(1,7);
  Serial.println(dieValue1);
  if(dieValue1 == 1){
    digitalWrite(seg1B, HIGH);
    digitalWrite(seg1C, HIGH);
  }
  if(dieValue1 == 2){
    digitalWrite(seg1A, HIGH);
    digitalWrite(seg1B, HIGH);
    digitalWrite(seg1D, HIGH);
    digitalWrite(seg1E, HIGH);
    digitalWrite(seg1G, HIGH);
  }
  if(dieValue1 == 3){
    digitalWrite(seg1A, HIGH);
    digitalWrite(seg1B, HIGH);
    digitalWrite(seg1C, HIGH);
    digitalWrite(seg1D, HIGH);
    digitalWrite(seg1G, HIGH);
  }
  if(dieValue1 == 4){
    digitalWrite(seg1B, HIGH);
    digitalWrite(seg1C, HIGH);
    digitalWrite(seg1F, HIGH);
    digitalWrite(seg1G, HIGH);
  }
  if(dieValue1 == 5){
    digitalWrite(seg1A, HIGH);
    digitalWrite(seg1C, HIGH);
    digitalWrite(seg1D, HIGH);
    digitalWrite(seg1F, HIGH);
    digitalWrite(seg1G, HIGH);
  }
  if(dieValue1 == 6){
    digitalWrite(seg1A, HIGH);
    digitalWrite(seg1C, HIGH);
    digitalWrite(seg1D, HIGH);
    digitalWrite(seg1E, HIGH);
    digitalWrite(seg1F, HIGH);
    digitalWrite(seg1G, HIGH);
  }
}

void dieRoll2() {
  spin2();
  randomSeed(analogRead(0));
  uint8_t dieValue2 = random(1,7);
  Serial.println(dieValue2);
  if(dieValue2 == 1){
    digitalWrite(seg1B, HIGH);
    digitalWrite(seg1C, HIGH);
  }
  if(dieValue2 == 2){
    digitalWrite(seg2A, HIGH);
    digitalWrite(seg2B, HIGH);
    digitalWrite(seg2D, HIGH);
    digitalWrite(seg2E, HIGH);
    digitalWrite(seg2G, HIGH);
  }
  if(dieValue2 == 3){
    digitalWrite(seg2A, HIGH);
    digitalWrite(seg2B, HIGH);
    digitalWrite(seg2C, HIGH);
    digitalWrite(seg2D, HIGH);
    digitalWrite(seg2G, HIGH);
  }
  if(dieValue2 == 4){
    digitalWrite(seg2B, HIGH);
    digitalWrite(seg2C, HIGH);
    digitalWrite(seg2F, HIGH);
    digitalWrite(seg2G, HIGH);
  }
  if(dieValue2 == 5){
    digitalWrite(seg2A, HIGH);
    digitalWrite(seg2C, HIGH);
    digitalWrite(seg2D, HIGH);
    digitalWrite(seg2F, HIGH);
    digitalWrite(seg2G, HIGH);
  }
  if(dieValue2 == 6){
    digitalWrite(seg2A, HIGH);
    digitalWrite(seg2C, HIGH);
    digitalWrite(seg2D, HIGH);
    digitalWrite(seg2E, HIGH);
    digitalWrite(seg2F, HIGH);
    digitalWrite(seg2G, HIGH);
  }
}

void dieRoll3() {
  spin3();
  randomSeed(analogRead(0));
  uint8_t dieValue3 = random(1,7);
  Serial.println(dieValue3);
  if(dieValue3 == 1){
    digitalWrite(seg3B, HIGH);
    digitalWrite(seg3C, HIGH);
  }
  if(dieValue3 == 2){
    digitalWrite(seg3A, HIGH);
    digitalWrite(seg3B, HIGH);
    digitalWrite(seg3D, HIGH);
    digitalWrite(seg3E, HIGH);
    digitalWrite(seg3G, HIGH);
  }
  if(dieValue3 == 3){
    digitalWrite(seg3A, HIGH);
    digitalWrite(seg3B, HIGH);
    digitalWrite(seg3C, HIGH);
    digitalWrite(seg3D, HIGH);
    digitalWrite(seg3G, HIGH);
  }
  if(dieValue3 == 4){
    digitalWrite(seg3B, HIGH);
    digitalWrite(seg3C, HIGH);
    digitalWrite(seg3F, HIGH);
    digitalWrite(seg3G, HIGH);
  }
  if(dieValue3 == 5){
    digitalWrite(seg3A, HIGH);
    digitalWrite(seg3C, HIGH);
    digitalWrite(seg3D, HIGH);
    digitalWrite(seg3F, HIGH);
    digitalWrite(seg3G, HIGH);
  }
  if(dieValue3 == 6){
    digitalWrite(seg3A, HIGH);
    digitalWrite(seg3C, HIGH);
    digitalWrite(seg3D, HIGH);
    digitalWrite(seg3E, HIGH);
    digitalWrite(seg3F, HIGH);
    digitalWrite(seg3G, HIGH);
  }
}

void dieRoll4() {
  spin4();
  randomSeed(analogRead(0));
  uint8_t dieValue4 = random(1,7);
  Serial.println(dieValue4);
  if(dieValue4 == 1){
    digitalWrite(seg4B, HIGH);
    digitalWrite(seg4C, HIGH);
  }
  if(dieValue4 == 2){
    digitalWrite(seg4A, HIGH);
    digitalWrite(seg4B, HIGH);
    digitalWrite(seg4D, HIGH);
    digitalWrite(seg4E, HIGH);
    digitalWrite(seg4G, HIGH);
  }
  if(dieValue4 == 3){
    digitalWrite(seg4A, HIGH);
    digitalWrite(seg4B, HIGH);
    digitalWrite(seg4C, HIGH);
    digitalWrite(seg4D, HIGH);
    digitalWrite(seg4G, HIGH);
  }
  if(dieValue4 == 4){
    digitalWrite(seg4B, HIGH);
    digitalWrite(seg4C, HIGH);
    digitalWrite(seg4F, HIGH);
    digitalWrite(seg4G, HIGH);
  }
  if(dieValue4 == 5){
    digitalWrite(seg4A, HIGH);
    digitalWrite(seg4C, HIGH);
    digitalWrite(seg4D, HIGH);
    digitalWrite(seg4F, HIGH);
    digitalWrite(seg4G, HIGH);
  }
  if(dieValue4 == 6){
    digitalWrite(seg4A, HIGH);
    digitalWrite(seg4C, HIGH);
    digitalWrite(seg4D, HIGH);
    digitalWrite(seg4E, HIGH);
    digitalWrite(seg4F, HIGH);
    digitalWrite(seg4G, HIGH);
  }
}

void checkSearch() {
  searchPinState = digitalRead(searchPin);
  delay(debounce);
  searchLEDState = digitalRead(searchLED);
  delay(debounce);
    if((searchPinState == LOW) && (searchLEDState == HIGH)) {
      dieRoll1();
      dieRoll2();
      dieRoll3();
      dieRoll4();
      digitalWrite(searchLED, LOW);
}
}

void checkSlew1() {
  slewPin1State = digitalRead(slewPin1);
  delay(debounce);
  lockLED1State = digitalRead(lockLED1);
 // nullLED1State = digitalRead(nullLED1);
  if((slewPin1State == LOW) && (lockLED1State == LOW))  { // && (nullLED1State = LOW)
      dieRoll1();
      digitalWrite(slewLED1, LOW);
      digitalWrite(lockLED1, HIGH);
}
}

void checkSlew2() {
  slewPin2State = digitalRead(slewPin2);
  delay(debounce);
  lockLED2State = digitalRead(lockLED2);
  //nullLED2State = digitalRead(nullLED2);
    if((slewPin2State == LOW) && (lockLED2State == LOW)) {  //&& (nullLED2State = LOW)
      dieRoll2();
      digitalWrite(slewLED2, LOW);
      digitalWrite(lockLED2, HIGH);
}
}

void checkSlew3() {
  slewPin3State = digitalRead(slewPin3);
  delay(debounce);
  lockLED3State = digitalRead(lockLED3);
 // nullLED3State = digitalRead(nullLED3);
    if((slewPin3State == LOW) && (lockLED3State == LOW)) {  // && (nullLED3State = LOW)
      dieRoll3();
      digitalWrite(slewLED3, LOW);
      digitalWrite(lockLED3, HIGH);
}
}

void checkSlew4() {
  slewPin4State = digitalRead(slewPin4);
  delay(debounce);
  lockLED4State = digitalRead(lockLED4);
  //nullLED4State = digitalRead(nullLED4);
    if((slewPin4State == LOW) && (lockLED4State == LOW)) {  // && (nullLED4State = LOW)
      dieRoll4();
      digitalWrite(slewLED4, LOW);
      digitalWrite(lockLED4, HIGH);
}
}


void checkLock1() {
  lockPin1Reading = digitalRead(lockPin1);
  delay(debounce);
  if (lockPin1Reading == LOW) {              
    lockLED1State = !lockLED1State;              
  }
    if (lockLED1State == true) {
    digitalWrite(lockLED1, HIGH);
    digitalWrite(slewLED1, LOW);
  }
    else {digitalWrite(lockLED1, LOW);
} 
}

void checkLock2() {
  lockPin2Reading = digitalRead(lockPin2);
  delay(debounce);
  if (lockPin2Reading == LOW) {              
    lockLED2State = !lockLED2State;              
  }
    if (lockLED2State == true) {
    digitalWrite(lockLED2, HIGH);
    digitalWrite(slewLED2, LOW);
  }
    else {digitalWrite(lockLED2, LOW);
  }
}

void checkLock3() {
  lockPin3Reading = digitalRead(lockPin3);
  delay(debounce);
  if (lockPin3Reading == LOW) {              
    lockLED3State = !lockLED3State;              
  }
    if (lockLED3State == true) {
    digitalWrite(lockLED3, HIGH);
    digitalWrite(slewLED3, LOW);
  }
    else {digitalWrite(lockLED3, LOW);
  }
}

void checkLock4() {
  lockPin4Reading = digitalRead(lockPin4);
  delay(debounce);
  if (lockPin4Reading == LOW) {              
    lockLED4State = !lockLED4State;              
  }
    if (lockLED4State == true) {
    digitalWrite(lockLED4, HIGH);
    digitalWrite(slewLED4, LOW);
  }
    else {digitalWrite(lockLED4, LOW);
  }
}

void checkNull1() {
  nullToggle1State = digitalRead(nullToggle1);
  delay(debounce);
    if(nullToggle1State == LOW) {
      digitalWrite(nullLED1, HIGH);
      digitalWrite(seg1A, LOW);
      digitalWrite(seg1B, LOW);
      digitalWrite(seg1C, LOW);
      digitalWrite(seg1D, LOW);
      digitalWrite(seg1E, LOW);
      digitalWrite(seg1F, LOW);
      digitalWrite(seg1G, HIGH);
}
}

void checkNull2() {
  nullToggle2State = digitalRead(nullToggle2);
  delay(debounce);
    if(nullToggle2State == LOW) {
      digitalWrite(nullLED2, HIGH);
      digitalWrite(seg2A, LOW);
      digitalWrite(seg2B, LOW);
      digitalWrite(seg2C, LOW);
      digitalWrite(seg2D, LOW);
      digitalWrite(seg2E, LOW);
      digitalWrite(seg2F, LOW);
      digitalWrite(seg2G, HIGH);
}
}

void checkNull3() {
  nullToggle3State = digitalRead(nullToggle3);
  delay(debounce);
    if(nullToggle3State == LOW) {
      digitalWrite(nullLED3, HIGH);
      digitalWrite(seg3A, LOW);
      digitalWrite(seg3B, LOW);
      digitalWrite(seg3C, LOW);
      digitalWrite(seg3D, LOW);
      digitalWrite(seg3E, LOW);
      digitalWrite(seg3F, LOW);
      digitalWrite(seg3G, HIGH);
}
}

void checkNull4() {
  nullToggle4State = digitalRead(nullToggle4);
  delay(debounce);
    if(nullToggle4State == LOW) {
      digitalWrite(nullLED4, HIGH);
      digitalWrite(seg4A, LOW);
      digitalWrite(seg4B, LOW);
      digitalWrite(seg4C, LOW);
      digitalWrite(seg4D, LOW);
      digitalWrite(seg4E, LOW);
      digitalWrite(seg4F, LOW);
      digitalWrite(seg4G, HIGH);
}
}

void checkReboot() {
 rebootPinState = digitalRead(rebootPin);
 delay(debounce);
 if (rebootPinState == LOW) {
  digitalWrite(slewLED1, HIGH);
  digitalWrite(slewLED2, HIGH);
  digitalWrite(slewLED3, HIGH);
  digitalWrite(slewLED4, HIGH);
 }
}

void checkReset() {
  nullLED1State = digitalRead(nullLED1);
  nullLED2State = digitalRead(nullLED2);
  nullLED3State = digitalRead(nullLED3);
  nullLED4State = digitalRead(nullLED4);
  nullToggle1State = digitalRead(nullToggle1);
  nullToggle2State = digitalRead(nullToggle2);
  nullToggle3State = digitalRead(nullToggle3);
  nullToggle4State = digitalRead(nullToggle4);
if((nullLED1State == HIGH) && (nullLED2State == HIGH) && (nullLED3State == HIGH) && (nullLED4State == HIGH) && 
  (nullToggle1State == HIGH) && (nullToggle2State == HIGH) && (nullToggle3State == HIGH) && (nullToggle4State == HIGH)) {
      digitalWrite(searchLED, HIGH);
      digitalWrite(lockLED1, LOW);
      digitalWrite(lockLED2, LOW);
      digitalWrite(lockLED3, LOW);
      digitalWrite(lockLED4, LOW);
      digitalWrite(slewLED1, LOW);
      digitalWrite(slewLED2, LOW);
      digitalWrite(slewLED3, LOW);
      digitalWrite(slewLED4, LOW);
      digitalWrite(nullLED1, LOW);
      digitalWrite(nullLED2, LOW);
      digitalWrite(nullLED3, LOW);
      digitalWrite(nullLED4, LOW);
      digitalWrite(seg1G, LOW);
      digitalWrite(seg2G, LOW);
      digitalWrite(seg3G, LOW);
      digitalWrite(seg4G, LOW);
  }
}

void setup() {
pinMode(searchLED, OUTPUT);
pinMode(searchPin, INPUT_PULLUP);
pinMode(slewPin1, INPUT_PULLUP);
pinMode(slewPin2, INPUT_PULLUP);
pinMode(slewPin3, INPUT_PULLUP);
pinMode(slewPin4, INPUT_PULLUP);
pinMode(slewLED1, OUTPUT);
pinMode(slewLED2, OUTPUT);
pinMode(slewLED3, OUTPUT);
pinMode(slewLED4, OUTPUT);
pinMode(lockPin1, INPUT_PULLUP);
pinMode(lockPin2, INPUT_PULLUP);
pinMode(lockPin3, INPUT_PULLUP);
pinMode(lockPin4, INPUT_PULLUP);
pinMode(lockLED1, OUTPUT);
pinMode(lockLED2, OUTPUT);
pinMode(lockLED3, OUTPUT);
pinMode(lockLED4, OUTPUT);
pinMode(nullToggle1, INPUT_PULLUP);
pinMode(nullToggle2, INPUT_PULLUP);
pinMode(nullToggle3, INPUT_PULLUP);
pinMode(nullToggle4, INPUT_PULLUP);
pinMode(nullLED1, OUTPUT);
pinMode(nullLED2, OUTPUT);
pinMode(nullLED3, OUTPUT);
pinMode(nullLED4, OUTPUT);
pinMode(seg1A, OUTPUT);
pinMode(seg1B, OUTPUT);
pinMode(seg1C, OUTPUT);
pinMode(seg1D, OUTPUT);
pinMode(seg1E, OUTPUT);
pinMode(seg1F, OUTPUT);
pinMode(seg1G, OUTPUT);
pinMode(seg2A, OUTPUT);
pinMode(seg2B, OUTPUT);
pinMode(seg2C, OUTPUT);
pinMode(seg2D, OUTPUT);
pinMode(seg2E, OUTPUT);
pinMode(seg2F, OUTPUT);
pinMode(seg2G, OUTPUT);
pinMode(seg3A, OUTPUT);
pinMode(seg3B, OUTPUT);
pinMode(seg3C, OUTPUT);
pinMode(seg3D, OUTPUT);
pinMode(seg3E, OUTPUT);
pinMode(seg3F, OUTPUT);
pinMode(seg3G, OUTPUT);
pinMode(seg4A, OUTPUT);
pinMode(seg4B, OUTPUT);
pinMode(seg4C, OUTPUT);
pinMode(seg4D, OUTPUT);
pinMode(seg4E,OUTPUT);
pinMode(seg4F, OUTPUT);
pinMode(seg4G, OUTPUT);
pinMode(rebootPin, INPUT_PULLUP);
digitalWrite(searchLED, HIGH);
Serial.begin(9600);
}



void loop() {        
                     
  checkSearch();
  checkReboot(); 
  checkSlew1();
  checkSlew2();
  checkSlew3();
  checkSlew4();
  checkLock1();
  checkLock2(); 
  checkLock3(); 
  checkLock4(); 
  checkNull1();
  checkNull2();
  checkNull3();
  checkNull4();
  checkReset();
 
}