/************************************************************
   SMART TRAFFIC SYSTEM + BLYNK + ESP32
   ---------------------------------------------------------
   FEATURES:
   ✅ 4-Way Traffic Lights
   ✅ Adaptive Traffic Timing
   ✅ Traffic Density Detection
   ✅ Emergency Vehicle Override
   ✅ Blynk Cloud Monitoring
   ✅ Real-Time Dashboard
   ✅ Wokwi Compatible
************************************************************/

//==========================================================
// BLYNK SETTINGS
//==========================================================

#define BLYNK_TEMPLATE_ID "TMPL2F1YhaOo5"
#define BLYNK_TEMPLATE_NAME "Smart Traffic Control System"
#define BLYNK_AUTH_TOKEN "E4t3cviu0ygYHfOIuMVQqvvTT4Z-mtMu"

//==========================================================
// LIBRARIES
//==========================================================

#include <WiFi.h>
#include <BlynkSimpleEsp32.h>

//==========================================================
// WIFI
//==========================================================

char ssid[] = "Wokwi-GUEST";
char pass[] = "";

//==========================================================
// TRAFFIC LIGHT PINS
//==========================================================

//---------------- LANE 1 ----------------
int L1_RED    = 27;
int L1_YELLOW = 26;
int L1_GREEN  = 25;

//---------------- LANE 2 ----------------
int L2_RED    = 4;
int L2_YELLOW = 16;
int L2_GREEN  = 17;

//---------------- LANE 3 ----------------
int L3_RED    = 33;
int L3_YELLOW = 32;
int L3_GREEN  = 18;

//---------------- LANE 4 ----------------
int L4_RED    = 13;
int L4_YELLOW = 12;
int L4_GREEN  = 14;

//==========================================================
// SENSOR BUTTONS
//==========================================================

int IR1 = 21;
int IR2 = 22;
int IR3 = 23;
int IR4 = 19;

//==========================================================
// EMERGENCY BUTTONS
//==========================================================

int EM1 = 5;
int EM2 = 15;
int EM3 = 2;
int EM4 = 34;

//==========================================================
// TIMING VARIABLES
//==========================================================

int normalGreen = 5000;
int highTrafficGreen = 9000;
int yellowTime = 2000;

//==========================================================
// BLYNK TIMER
//==========================================================

BlynkTimer timer;

//==========================================================
// FUNCTION: ALL RED
//==========================================================

void allRed() {

  digitalWrite(L1_RED, HIGH);
  digitalWrite(L2_RED, HIGH);
  digitalWrite(L3_RED, HIGH);
  digitalWrite(L4_RED, HIGH);

  digitalWrite(L1_YELLOW, LOW);
  digitalWrite(L2_YELLOW, LOW);
  digitalWrite(L3_YELLOW, LOW);
  digitalWrite(L4_YELLOW, LOW);

  digitalWrite(L1_GREEN, LOW);
  digitalWrite(L2_GREEN, LOW);
  digitalWrite(L3_GREEN, LOW);
  digitalWrite(L4_GREEN, LOW);
}

//==========================================================
// FUNCTION: SEND SENSOR DATA TO BLYNK
//==========================================================

void sendToBlynk() {

  int s1 = !digitalRead(IR1);
  int s2 = !digitalRead(IR2);
  int s3 = !digitalRead(IR3);
  int s4 = !digitalRead(IR4);

  Blynk.virtualWrite(V0, s1);
  Blynk.virtualWrite(V1, s2);
  Blynk.virtualWrite(V2, s3);
  Blynk.virtualWrite(V3, s4);

  Serial.print("Lane1: ");
  Serial.print(s1);

  Serial.print(" | Lane2: ");
  Serial.print(s2);

  Serial.print(" | Lane3: ");
  Serial.print(s3);

  Serial.print(" | Lane4: ");
  Serial.println(s4);
}

//==========================================================
// FUNCTION: GROUP A GREEN
//==========================================================

void groupAGreen(int duration) {

  allRed();

  digitalWrite(L1_RED, LOW);
  digitalWrite(L3_RED, LOW);

  digitalWrite(L1_GREEN, HIGH);
  digitalWrite(L3_GREEN, HIGH);

  Blynk.virtualWrite(V5, "Lane 1 & 3 GREEN");

  // Keep Blynk alive during delay
  unsigned long start = millis();

  while (millis() - start < duration) {
    Blynk.run();
    timer.run();
  }

  digitalWrite(L1_GREEN, LOW);
  digitalWrite(L3_GREEN, LOW);

  digitalWrite(L1_YELLOW, HIGH);
  digitalWrite(L3_YELLOW, HIGH);

  start = millis();

  while (millis() - start < yellowTime) {
    Blynk.run();
    timer.run();
  }

  digitalWrite(L1_YELLOW, LOW);
  digitalWrite(L3_YELLOW, LOW);
}

//==========================================================
// FUNCTION: GROUP B GREEN
//==========================================================

void groupBGreen(int duration) {

  allRed();

  digitalWrite(L2_RED, LOW);
  digitalWrite(L4_RED, LOW);

  digitalWrite(L2_GREEN, HIGH);
  digitalWrite(L4_GREEN, HIGH);

  Blynk.virtualWrite(V5, "Lane 2 & 4 GREEN");

  unsigned long start = millis();

  while (millis() - start < duration) {
    Blynk.run();
    timer.run();
  }

  digitalWrite(L2_GREEN, LOW);
  digitalWrite(L4_GREEN, LOW);

  digitalWrite(L2_YELLOW, HIGH);
  digitalWrite(L4_YELLOW, HIGH);

  start = millis();

  while (millis() - start < yellowTime) {
    Blynk.run();
    timer.run();
  }

  digitalWrite(L2_YELLOW, LOW);
  digitalWrite(L4_YELLOW, LOW);
}

//==========================================================
// FUNCTION: EMERGENCY MODE
//==========================================================

bool emergencyMode() {

  //======================================================
  // EMERGENCY LANE 1 & 3
  //======================================================

  if (digitalRead(EM1) == LOW || digitalRead(EM3) == LOW) {

    Serial.println("EMERGENCY → LANE 1 & 3");

    Blynk.virtualWrite(V4, 1);
    Blynk.virtualWrite(V5, "Emergency Lane 1 & 3");

    allRed();

    digitalWrite(L1_RED, LOW);
    digitalWrite(L3_RED, LOW);

    digitalWrite(L1_GREEN, HIGH);
    digitalWrite(L3_GREEN, HIGH);

    unsigned long start = millis();

    while (millis() - start < 8000) {
      Blynk.run();
      timer.run();
    }

    digitalWrite(L1_GREEN, LOW);
    digitalWrite(L3_GREEN, LOW);

    return true;
  }

  //======================================================
  // EMERGENCY LANE 2 & 4
  //======================================================

  if (digitalRead(EM2) == LOW || digitalRead(EM4) == LOW) {

    Serial.println("EMERGENCY → LANE 2 & 4");

    Blynk.virtualWrite(V4, 1);
    Blynk.virtualWrite(V5, "Emergency Lane 2 & 4");

    allRed();

    digitalWrite(L2_RED, LOW);
    digitalWrite(L4_RED, LOW);

    digitalWrite(L2_GREEN, HIGH);
    digitalWrite(L4_GREEN, HIGH);

    unsigned long start = millis();

    while (millis() - start < 8000) {
      Blynk.run();
      timer.run();
    }

    digitalWrite(L2_GREEN, LOW);
    digitalWrite(L4_GREEN, LOW);

    return true;
  }

  Blynk.virtualWrite(V4, 0);

  return false;
}

//==========================================================
// SETUP
//==========================================================

void setup() {

  Serial.begin(115200);

  //======================================================
  // CONNECT TO BLYNK
  //======================================================

  Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);

  //======================================================
  // LED OUTPUTS
  //======================================================

  pinMode(L1_RED, OUTPUT);
  pinMode(L1_YELLOW, OUTPUT);
  pinMode(L1_GREEN, OUTPUT);

  pinMode(L2_RED, OUTPUT);
  pinMode(L2_YELLOW, OUTPUT);
  pinMode(L2_GREEN, OUTPUT);

  pinMode(L3_RED, OUTPUT);
  pinMode(L3_YELLOW, OUTPUT);
  pinMode(L3_GREEN, OUTPUT);

  pinMode(L4_RED, OUTPUT);
  pinMode(L4_YELLOW, OUTPUT);
  pinMode(L4_GREEN, OUTPUT);

  //======================================================
  // SENSOR INPUTS
  //======================================================

  pinMode(IR1, INPUT_PULLUP);
  pinMode(IR2, INPUT_PULLUP);
  pinMode(IR3, INPUT_PULLUP);
  pinMode(IR4, INPUT_PULLUP);

  //======================================================
  // EMERGENCY INPUTS
  //======================================================

  pinMode(EM1, INPUT_PULLUP);
  pinMode(EM2, INPUT_PULLUP);
  pinMode(EM3, INPUT_PULLUP);

  // GPIO34 = INPUT ONLY
  pinMode(EM4, INPUT);

  //======================================================
  // TIMER
  //======================================================

  timer.setInterval(1000L, sendToBlynk);

  Serial.println("SMART TRAFFIC SYSTEM STARTED");
}

//==========================================================
// MAIN LOOP
//==========================================================

void loop() {

  Blynk.run();
  timer.run();

  //======================================================
  // CHECK EMERGENCY
  //======================================================

  if (emergencyMode()) {
    return;
  }

  //======================================================
  // TRAFFIC DENSITY
  //======================================================

  int lane13Traffic = (!digitalRead(IR1)) + (!digitalRead(IR3));
  int lane24Traffic = (!digitalRead(IR2)) + (!digitalRead(IR4));

  int timeA = normalGreen;
  int timeB = normalGreen;

  //======================================================
  // ADAPTIVE CONTROL
  //======================================================

  if (lane13Traffic > lane24Traffic) {

    timeA = highTrafficGreen;
    timeB = normalGreen;

  }
  else if (lane24Traffic > lane13Traffic) {

    timeA = normalGreen;
    timeB = highTrafficGreen;
  }

  Serial.print("Group A Time: ");
  Serial.print(timeA);

  Serial.print(" | Group B Time: ");
  Serial.println(timeB);

  //======================================================
  // RUN SYSTEM
  //======================================================

  groupAGreen(timeA);

  groupBGreen(timeB);
}