// Define the pins for the traffic lights
#define TRAFFIC_LIGHT_1_RED_PIN 2
#define TRAFFIC_LIGHT_1_YELLOW_PIN 3
#define TRAFFIC_LIGHT_1_GREEN_PIN 4

#define TRAFFIC_LIGHT_2_RED_PIN 5
#define TRAFFIC_LIGHT_2_YELLOW_PIN 6
#define TRAFFIC_LIGHT_2_GREEN_PIN 7

#define TRAFFIC_LIGHT_3_RED_PIN 8
#define TRAFFIC_LIGHT_3_YELLOW_PIN 9
#define TRAFFIC_LIGHT_3_GREEN_PIN 10

#define TRAFFIC_LIGHT_4_RED_PIN 11
#define TRAFFIC_LIGHT_4_YELLOW_PIN 12
#define TRAFFIC_LIGHT_4_GREEN_PIN 13

// Define the pins for the pedestrian lights
#define PEDESTRIAN_LIGHT_1_RED_PIN A0
#define PEDESTRIAN_LIGHT_1_GREEN_PIN A1

#define PEDESTRIAN_LIGHT_2_RED_PIN A2
#define PEDESTRIAN_LIGHT_2_GREEN_PIN A3

#define PEDESTRIAN_LIGHT_3_RED_PIN A4
#define PEDESTRIAN_LIGHT_3_GREEN_PIN A5

#define PEDESTRIAN_LIGHT_4_RED_PIN A6
#define PEDESTRIAN_LIGHT_4_GREEN_PIN A7

// Define the pins for the pedestrian buttons
#define PEDESTRIAN_BUTTON_1_PIN 14
#define PEDESTRIAN_BUTTON_2_PIN 15
#define PEDESTRIAN_BUTTON_3_PIN 16
#define PEDESTRIAN_BUTTON_4_PIN 17

// Define the waiting time for the traffic lights
#define TRAFFIC_LIGHT_WAIT_TIME 10000 // 10 seconds

// Define the waiting time for the pedestrian lights
#define PEDESTRIAN_LIGHT_WAIT_TIME 2000 // 2 seconds

// Define the waiting time for the pedestrian lights green
#define PEDESTRIAN_LIGHT_GREEN_TIME 10000 // 10 seconds

// Define the waiting time for the yellow blinking lights
#define YELLOW_BLINK_WAIT_TIME 500 // 0.5 seconds

// Define the state of the traffic lights
typedef enum {
  RED,
  YELLOW,
  GREEN
} TrafficLightState;

// Define the state of the pedestrian lights
typedef enum  {
  RED_PED,
  GREEN_PED
} PedestrianLightState;

// Define the state of the pedestrian buttons
typedef enum {
  NOT_PRESSED,
  PRESSED
} PedestrianButtonState;

// Initialize the state of the traffic lights
TrafficLightState trafficLightState1 = RED;
TrafficLightState trafficLightState2 = RED;
TrafficLightState trafficLightState3 = RED;
TrafficLightState trafficLightState4 = RED;

// Initialize the state of the pedestrian lights
PedestrianLightState pedestrianLightState1 = RED_PED;
PedestrianLightState pedestrianLightState2 = RED_PED;
PedestrianLightState pedestrianLightState3 = RED_PED;
PedestrianLightState pedestrianLightState4 = RED_PED;

// Initialize the state of the pedestrian buttons
PedestrianButtonState pedestrianButtonState1 = NOT_PRESSED;
PedestrianButtonState pedestrianButtonState2 = NOT_PRESSED;
PedestrianButtonState pedestrianButtonState3 = NOT_PRESSED;
PedestrianButtonState pedestrianButtonState4 = NOT_PRESSED;

// Function to handle the traffic lights
void handleTrafficLights() {
  // Check if all lights are red
  // Set the initial state of the traffic light to red
  trafficLightState1 = RED;
    digitalWrite(TRAFFIC_LIGHT_1_RED_PIN, HIGH);
  trafficLightState2 = RED;
    digitalWrite(TRAFFIC_LIGHT_2_RED_PIN, HIGH);
  trafficLightState3 = RED;
    digitalWrite(TRAFFIC_LIGHT_3_RED_PIN, HIGH);
  trafficLightState4 = RED;
    digitalWrite(TRAFFIC_LIGHT_4_RED_PIN, HIGH);
     pedestrianLightState1 = RED_PED;
    pedestrianLightState2 = RED_PED;
    pedestrianLightState3 = RED_PED;
    pedestrianLightState4 = RED_PED;
    digitalWrite(PEDESTRIAN_LIGHT_1_RED_PIN, HIGH);
    digitalWrite(PEDESTRIAN_LIGHT_2_RED_PIN, HIGH);
    digitalWrite(PEDESTRIAN_LIGHT_3_RED_PIN, HIGH);
    digitalWrite(PEDESTRIAN_LIGHT_4_RED_PIN, HIGH);
  
    if (trafficLightState1 == RED && trafficLightState2 == RED && trafficLightState3 == RED && trafficLightState4 == RED && pedestrianLightState1 == RED_PED && pedestrianLightState2 == RED_PED && pedestrianLightState3 == RED_PED && pedestrianLightState4 == RED_PED) {
    // Turn on the green light for one traffic light
    delay(1000); 
    trafficLightState1 = GREEN;
    digitalWrite(TRAFFIC_LIGHT_1_GREEN_PIN, HIGH);
  }
}

// Function to handle the pedestrian lights
void handlePedestrianLights() {
  // Check if the pedestrian button is pressed
  if (pedestrianButtonState1 == PRESSED || pedestrianButtonState2 == PRESSED || pedestrianButtonState3 == PRESSED || pedestrianButtonState4 == PRESSED) {
    // Blink the green light for the pedestrian lights
    pedestrianLightState1 = GREEN_PED;
    pedestrianLightState2 = GREEN_PED;
    pedestrianLightState3 = GREEN_PED;
    pedestrianLightState4 = GREEN_PED;
    delay(PEDESTRIAN_LIGHT_GREEN_TIME);
    for (int i = 0; i < 5; i++) {
      digitalWrite(PEDESTRIAN_LIGHT_1_GREEN_PIN, HIGH);
      digitalWrite(PEDESTRIAN_LIGHT_2_GREEN_PIN, HIGH);
      digitalWrite(PEDESTRIAN_LIGHT_3_GREEN_PIN, HIGH);
      digitalWrite(PEDESTRIAN_LIGHT_4_GREEN_PIN, HIGH);
      delay(PEDESTRIAN_LIGHT_WAIT_TIME);
      digitalWrite(PEDESTRIAN_LIGHT_1_GREEN_PIN, LOW);
      digitalWrite(PEDESTRIAN_LIGHT_2_GREEN_PIN, LOW);
      digitalWrite(PEDESTRIAN_LIGHT_3_GREEN_PIN, LOW);
      digitalWrite(PEDESTRIAN_LIGHT_4_GREEN_PIN, LOW);
      delay(PEDESTRIAN_LIGHT_WAIT_TIME);
    }
    // Turn off the green light for the pedestrian lights
    pedestrianLightState1 = RED_PED;
    pedestrianLightState2 = RED_PED;
    pedestrianLightState3 = RED_PED;
    pedestrianLightState4 = RED_PED;
    digitalWrite(PEDESTRIAN_LIGHT_1_GREEN_PIN, LOW);
    digitalWrite(PEDESTRIAN_LIGHT_2_GREEN_PIN, LOW);
    digitalWrite(PEDESTRIAN_LIGHT_3_GREEN_PIN, LOW);
    digitalWrite(PEDESTRIAN_LIGHT_4_GREEN_PIN, LOW);
  }
}

// Function to handle the yellow blinking lights
void handleYellowBlinkingLights() {
  // Blink the yellow light for all traffic lights
  for (int i = 0; i < 5; i++) {
    digitalWrite(TRAFFIC_LIGHT_1_YELLOW_PIN, HIGH);
    digitalWrite(TRAFFIC_LIGHT_2_YELLOW_PIN, HIGH);
    digitalWrite(TRAFFIC_LIGHT_3_YELLOW_PIN, HIGH);
    digitalWrite(TRAFFIC_LIGHT_4_YELLOW_PIN, HIGH);
    delay(YELLOW_BLINK_WAIT_TIME);
    digitalWrite(TRAFFIC_LIGHT_1_YELLOW_PIN, LOW);
    digitalWrite(TRAFFIC_LIGHT_2_YELLOW_PIN, LOW);
    digitalWrite(TRAFFIC_LIGHT_3_YELLOW_PIN, LOW);
    digitalWrite(TRAFFIC_LIGHT_4_YELLOW_PIN, LOW);
    delay(YELLOW_BLINK_WAIT_TIME);
  }
}

void setup() {
  // Set the pin modes for the traffic lights
  pinMode(TRAFFIC_LIGHT_1_RED_PIN, OUTPUT);
  pinMode(TRAFFIC_LIGHT_1_YELLOW_PIN, OUTPUT);
  pinMode(TRAFFIC_LIGHT_1_GREEN_PIN, OUTPUT);

  pinMode(TRAFFIC_LIGHT_2_RED_PIN, OUTPUT);
  pinMode(TRAFFIC_LIGHT_2_YELLOW_PIN, OUTPUT);
  pinMode(TRAFFIC_LIGHT_2_GREEN_PIN, OUTPUT);

  pinMode(TRAFFIC_LIGHT_3_RED_PIN, OUTPUT);
  pinMode(TRAFFIC_LIGHT_3_YELLOW_PIN, OUTPUT);
  pinMode(TRAFFIC_LIGHT_3_GREEN_PIN, OUTPUT);

  pinMode(TRAFFIC_LIGHT_4_RED_PIN, OUTPUT);
  pinMode(TRAFFIC_LIGHT_4_YELLOW_PIN, OUTPUT);
  pinMode(TRAFFIC_LIGHT_4_GREEN_PIN, OUTPUT);

  // Set the pin modes for the pedestrian lights
  pinMode(PEDESTRIAN_LIGHT_1_RED_PIN, OUTPUT);
  pinMode(PEDESTRIAN_LIGHT_1_GREEN_PIN, OUTPUT);

  pinMode(PEDESTRIAN_LIGHT_2_RED_PIN, OUTPUT);
  pinMode(PEDESTRIAN_LIGHT_2_GREEN_PIN, OUTPUT);

  pinMode(PEDESTRIAN_LIGHT_3_RED_PIN, OUTPUT);
  pinMode(PEDESTRIAN_LIGHT_3_GREEN_PIN, OUTPUT);

  pinMode(PEDESTRIAN_LIGHT_4_RED_PIN, OUTPUT);
  pinMode(PEDESTRIAN_LIGHT_4_GREEN_PIN, OUTPUT);

  // Set the pin modes for the pedestrian buttons
  pinMode(PEDESTRIAN_BUTTON_1_PIN, INPUT_PULLUP);
  pinMode(PEDESTRIAN_BUTTON_2_PIN, INPUT_PULLUP);
  pinMode(PEDESTRIAN_BUTTON_3_PIN, INPUT_PULLUP);
  pinMode(PEDESTRIAN_BUTTON_4_PIN, INPUT_PULLUP);
}

void loop() {
  // Check the state of the pedestrian buttons
  pedestrianButtonState1 = digitalRead(PEDESTRIAN_BUTTON_1_PIN) == LOW ? PRESSED : NOT_PRESSED;
  pedestrianButtonState2 = digitalRead(PEDESTRIAN_BUTTON_2_PIN) == LOW ? PRESSED : NOT_PRESSED;
  pedestrianButtonState3 = digitalRead(PEDESTRIAN_BUTTON_3_PIN) == LOW ? PRESSED : NOT_PRESSED;
  pedestrianButtonState4 = digitalRead(PEDESTRIAN_BUTTON_4_PIN) == LOW ? PRESSED : NOT_PRESSED;

  // Handle the traffic lights
  handleTrafficLights();

  // Handle the pedestrian lights
  handlePedestrianLights();

  // Check if the pedestrian button is pressed
  if (pedestrianButtonState1 == PRESSED || pedestrianButtonState2 == PRESSED || pedestrianButtonState3 == PRESSED || pedestrianButtonState4 == PRESSED) {
    // Handle the yellow blinking lights
    handleYellowBlinkingLights();
  }

  // Check the state of the traffic lights and update the pins accordingly
  digitalWrite(TRAFFIC_LIGHT_1_RED_PIN, trafficLightState1 == RED ? HIGH : LOW);
  digitalWrite(TRAFFIC_LIGHT_1_YELLOW_PIN, trafficLightState1 == YELLOW ? HIGH : LOW);
  digitalWrite(TRAFFIC_LIGHT_1_GREEN_PIN, trafficLightState1 == GREEN ? HIGH : LOW);

  digitalWrite(TRAFFIC_LIGHT_2_RED_PIN, trafficLightState2 == RED ? HIGH : LOW);
  digitalWrite(TRAFFIC_LIGHT_2_YELLOW_PIN, trafficLightState2 == YELLOW ? HIGH : LOW);
  digitalWrite(TRAFFIC_LIGHT_2_GREEN_PIN, trafficLightState2 == GREEN ? HIGH : LOW);

  digitalWrite(TRAFFIC_LIGHT_3_RED_PIN, trafficLightState3 == RED ? HIGH : LOW);
  digitalWrite(TRAFFIC_LIGHT_3_YELLOW_PIN, trafficLightState3 == YELLOW ? HIGH : LOW);
  digitalWrite(TRAFFIC_LIGHT_3_GREEN_PIN, trafficLightState3 == GREEN ? HIGH : LOW);

  digitalWrite(TRAFFIC_LIGHT_4_RED_PIN, trafficLightState4 == RED ? HIGH : LOW);
  digitalWrite(TRAFFIC_LIGHT_4_YELLOW_PIN, trafficLightState4 == YELLOW ? HIGH : LOW);
  digitalWrite(TRAFFIC_LIGHT_4_GREEN_PIN, trafficLightState4 == GREEN ? HIGH : LOW);

  // Delay for the traffic light wait time
  delay(TRAFFIC_LIGHT_WAIT_TIME);
}