// Define pins for the signal lights
const int leftSignalPin = 2;
const int rightSignalPin = 3;
const int leftSwitchPin = 4;
const int rightSwitchPin = 5;

// Define pins for the wiper control
const int wiperMotorPin = 9;
const int wiperSwitchPin = 6; // Switch to control the wiper

// Define pin for the emergency light switch
const int emergencySwitchPin = 7;

// Define pin for the sprinkler switch and control
const int sprinklerSwitchPin = 8;
const int sprinklerControlPin = 10; // Pin to control the sprinkler

// Variables for non-blocking timing
unsigned long previousMillis = 0;
const long interval = 500; // Interval at which to blink (milliseconds)
bool emergencyState = false;

// Variables for sprinkler and wiper timing
unsigned long sprinklerOffTime = 0;
const long wiperDelay = 2500; // 2.5 seconds delay
bool wiperOnAfterSprinkler = false;

// Variables for signal lights
unsigned long leftPreviousBlinkMillis = 0;
bool leftSignalState = false;

unsigned long rightPreviousBlinkMillis = 0;
bool rightSignalState = false;

// Variables for left signal switch press duration
unsigned long leftSwitchPressStart = 0;
bool leftSwitchActive = false;

// Variables for right signal switch press duration
unsigned long rightSwitchPressStart = 0;
bool rightSwitchActive = false;

void setup() {
  // Initialize signal light pins
  pinMode(leftSignalPin, OUTPUT);
  pinMode(rightSignalPin, OUTPUT);
  pinMode(leftSwitchPin, INPUT_PULLUP);
  pinMode(rightSwitchPin, INPUT_PULLUP);

  // Initialize wiper motor pin
  pinMode(wiperMotorPin, OUTPUT);
  pinMode(wiperSwitchPin, INPUT_PULLUP); // Set the wiper switch pin as input with pull-up

  // Initialize emergency switch pin
  pinMode(emergencySwitchPin, INPUT_PULLUP);

  // Initialize sprinkler pins
  pinMode(sprinklerSwitchPin, INPUT_PULLUP);
  pinMode(sprinklerControlPin, OUTPUT);

  // Start with LEDs off and sprinkler off
  digitalWrite(leftSignalPin, LOW);
  digitalWrite(rightSignalPin, LOW);
  digitalWrite(sprinklerControlPin, LOW);
  digitalWrite(wiperMotorPin, LOW);
}

void loop() {
  unsigned long currentMillis = millis();

  // Read the state of the switches
  int leftSwitchState = digitalRead(leftSwitchPin);
  int rightSwitchState = digitalRead(rightSwitchPin);
  int wiperSwitchState = digitalRead(wiperSwitchPin);
  int emergencySwitchState = digitalRead(emergencySwitchPin);
  int sprinklerSwitchState = digitalRead(sprinklerSwitchPin);

  // Handle emergency light
  if (emergencySwitchState == LOW) {
    if (currentMillis - previousMillis >= interval) {
      previousMillis = currentMillis;
      emergencyState = !emergencyState;
      digitalWrite(leftSignalPin, emergencyState ? HIGH : LOW);
      digitalWrite(rightSignalPin, emergencyState ? HIGH : LOW);
    }
  } else {
    // Handle left signal light
    if (leftSwitchState == LOW && !rightSwitchActive) {
      if (!leftSwitchActive) {
        leftSwitchActive = true;
        leftPreviousBlinkMillis = currentMillis; // Initialize to current time to avoid short flash
      }
      if (currentMillis - leftPreviousBlinkMillis >= interval) {
        leftPreviousBlinkMillis = currentMillis;
        leftSignalState = !leftSignalState;
        digitalWrite(leftSignalPin, leftSignalState ? HIGH : LOW);
      }
    } else {
      leftSwitchActive = false;
      digitalWrite(leftSignalPin, LOW);
      leftSignalState = false;
    }

    // Handle right signal light
    if (rightSwitchState == LOW && !leftSwitchActive) {
      if (!rightSwitchActive) {
        rightSwitchActive = true;
        rightPreviousBlinkMillis = currentMillis; // Initialize to current time to avoid short flash
      }
      if (currentMillis - rightPreviousBlinkMillis >= interval) {
        rightPreviousBlinkMillis = currentMillis;
        rightSignalState = !rightSignalState;
        digitalWrite(rightSignalPin, rightSignalState ? HIGH : LOW);
      }
    } else {
      rightSwitchActive = false;
      digitalWrite(rightSignalPin, LOW);
      rightSignalState = false;
    }
  }

  // Control the wiper motor
  if (wiperSwitchState == LOW) {
    digitalWrite(wiperMotorPin, HIGH); // Turn the wiper motor on
    wiperOnAfterSprinkler = false; // Reset the flag since we are manually controlling the wiper
  } else if (wiperSwitchState == HIGH && !wiperOnAfterSprinkler) {
    digitalWrite(wiperMotorPin, LOW); // Turn the wiper motor off
  } else if (currentMillis - sprinklerOffTime >= wiperDelay && wiperOnAfterSprinkler) {
    digitalWrite(wiperMotorPin, LOW); // Turn the wiper motor off after delay
    wiperOnAfterSprinkler = false; // Reset the flag
  }

  // Control the sprinkler
  if (sprinklerSwitchState == LOW) {
    digitalWrite(sprinklerControlPin, HIGH); // Turn the sprinkler on
    digitalWrite(wiperMotorPin, HIGH); // Turn the wiper motor on when sprinkler is on
    wiperOnAfterSprinkler = true; // Set the flag indicating wiper should stay on after sprinkler
  } else if (digitalRead(sprinklerControlPin) == HIGH) {
    digitalWrite(sprinklerControlPin, LOW); // Turn the sprinkler off
    sprinklerOffTime = currentMillis; // Record the time when sprinkler is turned off
  }
}