// Define pin mappings for relay boards
const int relayBoard1Pins[] = {39, 41, 43, 45, 47, 49, 51, 53};
const int relayBoard2Pins[] = {38, 40, 42, 44, 46, 48, 50, 52};
const int relayBoard3Pins[] = {69, 68, 67, 66, 65, 64, 63, 62};

// Define switch and LED pin mappings
const int switchPins[] = {13, 11, 9, 7, 5, 3, 14, 16, 18, 20, 24, 25, 30, 31};
const int switchLEDs[] = {12, 10, 8, 6, 4, 2, 15, 17, 19, 21, 26, 27, 32, 33};
const int switchSecondaryLEDs[] = {28, 29, 34, 35};

// Relay state variables
bool relayBoard1State[8] = {false, false, false, false, false, false, false, false};
bool relayBoard2State[8] = {false, false, false, false, false, false, false, false};
bool relayBoard3State[8] = {false, false, false, false, false, false, false, false};

// Switch state variables
bool lastSwitchState[14] = {HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH};

void setup() {
  // Initialize relay control pins
  for (int i = 0; i < 8; ++i) {
    pinMode(relayBoard1Pins[i], OUTPUT);
    pinMode(relayBoard2Pins[i], OUTPUT);
    pinMode(relayBoard3Pins[i], OUTPUT);
    digitalWrite(relayBoard1Pins[i], HIGH);
    digitalWrite(relayBoard2Pins[i], HIGH);  // Set all relays on relay board 2 to HIGH
    digitalWrite(relayBoard3Pins[i], HIGH);
  }

  // Initialize switch and LED pins
  for (int i = 0; i < 14; ++i) {
    pinMode(switchPins[i], INPUT_PULLUP);
    pinMode(switchLEDs[i], OUTPUT);
    if (i >= 4) {
      pinMode(switchSecondaryLEDs[i - 4], OUTPUT);
    }
  }

  // Set initial LED states
  digitalWrite(switchLEDs[0], HIGH); // Switch 1 LED is initially ON
  digitalWrite(switchLEDs[1], LOW);  // Switch 2 LED is initially OFF
  digitalWrite(switchLEDs[2], LOW);  // Switch 3 LED is initially OFF
  digitalWrite(switchLEDs[3], LOW);  // Switch 4 LED is initially OFF
  digitalWrite(switchLEDs[4], LOW);  // Switch 5 LED is initially OFF
  digitalWrite(switchLEDs[5], LOW);  // Switch 6 LED is initially OFF
  digitalWrite(switchLEDs[6], LOW);  // Switch 7 LED is initially OFF
  digitalWrite(switchLEDs[7], LOW);  // Switch 8 LED is initially OFF
  digitalWrite(switchLEDs[8], LOW);  // Switch 9 LED is initially OFF
  digitalWrite(switchLEDs[9], LOW);  // Switch 10 LED is initially OFF
  for (int i = 10; i < 14; ++i) {
    digitalWrite(switchLEDs[i], HIGH);            // Primary LED is initially ON
    digitalWrite(switchSecondaryLEDs[i - 4], LOW); // Secondary LED is initially OFF
  }
digitalWrite(relayBoard3Pins[1], HIGH);
digitalWrite(relayBoard3Pins[2], HIGH);
digitalWrite(relayBoard3Pins[3], HIGH);
digitalWrite(relayBoard3Pins[4], HIGH);
digitalWrite(relayBoard3Pins[5], HIGH);
digitalWrite(relayBoard3Pins[6], HIGH);
digitalWrite(relayBoard3Pins[7], HIGH);
digitalWrite(relayBoard3Pins[8], HIGH);
digitalWrite(relayBoard1Pins[1], HIGH);
digitalWrite(relayBoard1Pins[2], HIGH);
digitalWrite(relayBoard1Pins[3], HIGH);
digitalWrite(relayBoard1Pins[4], HIGH);
digitalWrite(relayBoard1Pins[5], HIGH);
digitalWrite(relayBoard1Pins[6], HIGH);
digitalWrite(relayBoard1Pins[7], HIGH);
digitalWrite(relayBoard1Pins[8], HIGH);
}

void loop() {
  for (int i = 0; i < 14; ++i) {
    bool switchState = digitalRead(switchPins[i]);
    if (switchState == LOW && lastSwitchState[i] == HIGH) {
      handleSwitchPress(i);
      delay(200); // Debounce delay
    }
    lastSwitchState[i] = switchState;
  }
}

void handleSwitchPress(int switchIndex) {
  switch (switchIndex) {
    case 0: // Switch 1
      setRelayStates(relayBoard2Pins, 0, 8, HIGH);
      // setRelayStates(relayBoard3Pins, 0, 8, HIGH);
      setRelayStates(relayBoard1Pins, 0, 4, HIGH);
      setLEDStates(0, HIGH);
      break;
    case 1: // Switch 2
      setRelayStates(relayBoard1Pins, 0, 2, LOW);
      setRelayStates(relayBoard1Pins, 2, 4, HIGH);
      setLEDStates(1, HIGH);
      syncSwitch12WithSwitch11();
      break;
    case 2: // Switch 3
      setRelayStates(relayBoard1Pins, 0, 2, HIGH);
      setRelayStates(relayBoard1Pins, 2, 4, LOW);
      setLEDStates(2, HIGH);
      syncSwitch13WithSwitch12();
      break;
    case 3: // Switch 4
      setRelayStates(relayBoard1Pins, 0, 4, LOW);
      setLEDStates(3, HIGH);
      syncSwitch12And13WithSwitch11();
      break;
    case 4: // Switch 5
      toggleRelays(relayBoard3Pins, 0, 1);
      toggleLEDs(switchLEDs[4], 99);
      break;
    case 5: // Switch 6
      toggleRelays(relayBoard3Pins, 1, 2);
      toggleLEDs(switchLEDs[5], 99);
      break;
    case 6: // Switch 7
      toggleRelays(relayBoard3Pins, 2, 3);
      toggleLEDs(switchLEDs[6], 99);
      break;
    case 7: // Switch 8
      toggleRelays(relayBoard3Pins, 3, 4);
      toggleLEDs(switchLEDs[7], 99);
      break;
    case 8: // Switch 9
      toggleRelays(relayBoard3Pins, 4, 5);
      toggleLEDs(switchLEDs[8], 99);
      break;
    case 9: // Switch 10
      toggleRelays(relayBoard3Pins, 5, 6);
      toggleLEDs(switchLEDs[9], 99);
      break;  
    case 10: // Switch 11
      toggleRelays(relayBoard2Pins, 0, 2);
      toggleLEDs(switchLEDs[10], switchSecondaryLEDs[0]);
      break;
    case 11: // Switch 12
      toggleRelays(relayBoard2Pins, 2, 4);
      toggleLEDs(switchLEDs[11], switchSecondaryLEDs[1]);
      break;
    case 12: // Switch 13
      toggleRelays(relayBoard2Pins, 4, 6);
      toggleLEDs(switchLEDs[12], switchSecondaryLEDs[2]);
      break;
    case 13: // Switch 14
      toggleRelays(relayBoard2Pins, 6, 8);
      toggleLEDs(switchLEDs[13], switchSecondaryLEDs[3]);
      break;
  }
}

void setRelayStates(const int *relayPins, int start, int end, int state) {
  for (int i = start; i < end; ++i) {
    digitalWrite(relayPins[i], state);
  }
}

void setLEDStates(int switchIndex, int state) {
  for (int i = 0; i < 4; ++i) {
    digitalWrite(switchLEDs[i], LOW);
  }
  digitalWrite(switchLEDs[switchIndex], state);
}

void toggleRelays(const int *relayPins, int start, int end) {
  for (int i = start; i < end; ++i) {
    bool currentState = digitalRead(relayPins[i]);
    digitalWrite(relayPins[i], !currentState);
  }
}

void toggleLEDs(int primaryLEDPin, int secondaryLEDPin) {
  bool primaryState = digitalRead(primaryLEDPin);
  digitalWrite(primaryLEDPin, !primaryState);
  if (secondaryLEDPin != 99) {
    digitalWrite(secondaryLEDPin, primaryState);
  }
}

void syncSwitch12WithSwitch11() {
  // Match the state of switch 12 with switch 11
  bool switch11PrimaryState = digitalRead(switchLEDs[10]);
  bool switch11SecondaryState = digitalRead(switchSecondaryLEDs[0]);

  digitalWrite(switchLEDs[11], switch11PrimaryState);
  digitalWrite(switchSecondaryLEDs[1], switch11SecondaryState);

  // Set relays for switch 12 to match switch 11
  int startRelay = 2;
  int endRelay = 4;
  for (int i = startRelay; i < endRelay; ++i) {
    bool currentState = digitalRead(relayBoard2Pins[i - 2]);
    digitalWrite(relayBoard2Pins[i], currentState);
  }
}

void syncSwitch13WithSwitch12() {
  // Match the state of switch 13 with switch 12
  bool switch12PrimaryState = digitalRead(switchLEDs[11]);
  bool switch12SecondaryState = digitalRead(switchSecondaryLEDs[1]);

  digitalWrite(switchLEDs[12], switch12PrimaryState);
  digitalWrite(switchSecondaryLEDs[2], switch12SecondaryState);

  // Set relays for switch 13 to match switch 12
  int startRelay = 4;
  int endRelay = 6;
  for (int i = startRelay; i < endRelay; ++i) {
    bool currentState = digitalRead(relayBoard2Pins[i - 2]);
    digitalWrite(relayBoard2Pins[i], currentState);
  }
}

void syncSwitch12And13WithSwitch11() {
  // Match the state of switch 12 with switch 11
  syncSwitch12WithSwitch11();
  // Match the state of switch 13 with switch 11
  syncSwitch13WithSwitch12();
}